diff --git a/.circleci/config.yml b/.circleci/config.yml
index ed1d54f2d..2f61bf444 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -3,7 +3,7 @@ version: 2
 defaults: &linux_defaults
   working_directory: /go/src/github.com/cosmos/cosmos-sdk
   docker:
-    - image: circleci/golang:1.11.5
+    - image: circleci/golang:1.12.1
   environment:
     GOBIN: /tmp/workspace/bin
 
@@ -17,7 +17,7 @@ macos_config: &macos_defaults
     xcode: "10.1.0"
   working_directory: /Users/distiller/project/src/github.com/cosmos/cosmos-sdk
   environment:
-    GO_VERSION: "1.11.5"
+    GO_VERSION: "1.12.1"
 
 set_macos_env: &macos_env
   run:
@@ -27,6 +27,7 @@ set_macos_env: &macos_env
       echo 'export GOPATH=$HOME/project' >> $BASH_ENV
       echo 'export GOBIN=$GOPATH/bin' >> $BASH_ENV
       echo 'export PATH=$PATH:$HOME/go/bin:$GOBIN' >> $BASH_ENV
+      echo 'export GO111MODULE=on'
 
 ############
 #
@@ -35,7 +36,7 @@ set_macos_env: &macos_env
 docs_update: &docs_deploy
   working_directory: ~/repo
   docker:
-    - image: tendermint/docs_deployment
+    - image: tendermintdev/jq_curl
   environment:
     AWS_REGION: us-east-1
 
@@ -44,7 +45,6 @@ deps: &dependencies
     name: dependencies
     command: |
       export PATH="$GOBIN:$PATH"
-      make vendor-deps
 
 jobs:
   setup_dependencies:
@@ -53,6 +53,9 @@ jobs:
       - run: mkdir -p /tmp/workspace/bin
       - run: mkdir -p /tmp/workspace/profiles
       - checkout
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: tools
           command: |
@@ -63,7 +66,12 @@ jobs:
           name: binaries
           command: |
             export PATH="$GOBIN:$PATH"
+            make go-mod-cache
             make install
+      - save_cache:
+          key: go-mod-v1-{{ checksum "go.sum" }}
+          paths:
+            - "/go/pkg/mod"
       - persist_to_workspace:
           root: /tmp/workspace
           paths:
@@ -78,17 +86,14 @@ jobs:
           at: /tmp/workspace
       - checkout
       - *dependencies
-      - run:
-          name: Get metalinter
-          command: |
-            export PATH="$GOBIN:$PATH"
-            make devtools-clean
-            make devtools
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Lint source
           command: |
             export PATH="$GOBIN:$PATH"
-            make test_lint
+            make ci-lint
 
   integration_tests:
     <<: *linux_defaults
@@ -98,6 +103,9 @@ jobs:
           at: /tmp/workspace
       - checkout
       - *dependencies
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Test cli
           command: |
@@ -112,6 +120,9 @@ jobs:
           at: /tmp/workspace
       - checkout
       - *dependencies
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Test individual module simulations
           command: |
@@ -126,6 +137,9 @@ jobs:
           at: /tmp/workspace
       - checkout
       - *dependencies
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Test full Gaia simulation
           command: |
@@ -140,6 +154,9 @@ jobs:
           at: /tmp/workspace
       - checkout
       - *dependencies
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Test Gaia import/export simulation
           command: |
@@ -154,6 +171,9 @@ jobs:
           at: /tmp/workspace
       - checkout
       - *dependencies
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Test Gaia import/export simulation
           command: |
@@ -168,10 +188,14 @@ jobs:
           at: /tmp/workspace
       - checkout
       - *dependencies
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Test multi-seed Gaia simulation long
           command: |
             export PATH="$GOBIN:$PATH"
+            export GO111MODULE=on
             scripts/multisim.sh 500 50 TestFullGaiaSimulation
 
   test_sim_gaia_multi_seed:
@@ -182,10 +206,14 @@ jobs:
           at: /tmp/workspace
       - checkout
       - *dependencies
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Test multi-seed Gaia simulation short
           command: |
             export PATH="$GOBIN:$PATH"
+            export GO111MODULE=on
             scripts/multisim.sh 50 10 TestFullGaiaSimulation
 
   test_cover:
@@ -197,14 +225,18 @@ jobs:
       - checkout
       - *dependencies
       - run: mkdir -p /tmp/logs
+      - restore_cache:
+          keys:
+            - go-mod-v1-{{ checksum "go.sum" }}
       - run:
           name: Run tests
           command: |
             export PATH="$GOBIN:$PATH"
             export VERSION="$(git describe --tags --long | sed 's/v\(.*\)/\1/')"
+            export GO111MODULE=on
             for pkg in $(go list ./... | grep -v github.com/cosmos/cosmos-sdk/cmd/gaia/cli_test | grep -v '/simulation' | circleci tests split --split-by=timings); do
               id=$(echo "$pkg" | sed 's|[/.]|_|g')
-              GOCACHE=off go test -timeout 8m -race -coverprofile=/tmp/workspace/profiles/$id.out -covermode=atomic -tags='ledger test_ledger_mock' "$pkg" | tee "/tmp/logs/$id-$RANDOM.log"
+              go test -mod=readonly -timeout 8m -race -coverprofile=/tmp/workspace/profiles/$id.out -covermode=atomic -tags='ledger test_ledger_mock' "$pkg" | tee "/tmp/logs/$id-$RANDOM.log"
             done
       - persist_to_workspace:
           root: /tmp/workspace
@@ -253,7 +285,7 @@ jobs:
         GOPATH: /home/circleci/.go_workspace/
         GOOS: linux
         GOARCH: amd64
-        GO_VERSION: "1.11.5"
+        GO_VERSION: "1.12.1"
       parallelism: 1
       steps:
         - checkout
@@ -268,7 +300,6 @@ jobs:
               popd
               set -x
               make tools
-              make vendor-deps
               make build-linux
               make localnet-start
               ./scripts/localnet-blocks-test.sh 40 5 10 localhost
@@ -280,7 +311,22 @@ jobs:
       - run:
           name: Trigger website build
           command: |
-            chamber exec cosmos-sdk -- start_website_build
+            curl --silent \
+                 --show-error \
+                 -X POST \
+                 --header "Content-Type: application/json" \
+                 -d "{\"branch\": \"$CIRCLE_BRANCH\"}" \
+                 "https://circleci.com/api/v1.1/project/github/$CIRCLE_PROJECT_USERNAME/$WEBSITE_REPO_NAME/build?circle-token=$TENDERBOT_API_TOKEN" > response.json
+
+            RESULT=`jq -r '.status' response.json`
+            MESSAGE=`jq -r '.message' response.json`
+
+            if [[ ${RESULT} == "null" ]] || [[ ${RESULT} -ne "200" ]]; then
+                echo "CircleCI API call failed: $MESSAGE"
+                exit 1
+            else
+                echo "Website build started"
+            fi
 
   macos_ci:
     <<: *macos_defaults
@@ -300,7 +346,6 @@ jobs:
           command: |
             source $BASH_ENV
             make tools
-            make vendor-deps
             make install
       - run:
           name: Integration tests
@@ -322,14 +367,19 @@ jobs:
       - setup_remote_docker:
           docker_layer_caching: true
       - run: |
-          if [ "${CIRCLE_BRANCH}" == "master" ]; then
+          GAIAD_VERSION=''
+          if [ "${CIRCLE_BRANCH}" = "master" ]; then
             GAIAD_VERSION="stable"
-          elif [ "${CIRCLE_BRANCH}" == "develop" ]; then
+          elif [ "${CIRCLE_BRANCH}" = "develop" ]; then
             GAIAD_VERSION="develop"
           fi
-          docker build -t tendermint/gaia:$GAIAD_VERSION .
-          docker login -u $DOCKER_USER -p $DOCKER_PASS
-          docker push tendermint/gaia:$GAIAD_VERSION
+          if [ -z "${GAIAD_VERSION}" ]; then
+            docker build .
+          else
+            docker build -t tendermint/gaia:$GAIAD_VERSION .
+            docker login -u $DOCKER_USER -p $DOCKER_PASS
+            docker push tendermint/gaia:$GAIAD_VERSION
+          fi
 
   docker_tagged:
     <<: *linux_defaults
@@ -349,11 +399,6 @@ workflows:
   test-suite:
     jobs:
       - docker_image:
-          filters:
-            branches:
-              only:
-                - master
-                - develop
           requires:
             - setup_dependencies
       - docker_tagged:
@@ -378,7 +423,12 @@ workflows:
               only:
                 - master
                 - develop
-      - setup_dependencies
+      - setup_dependencies:
+          # filters here are needed to enable this job also for tags
+          filters:
+            tags:
+              only:
+                - /^v.*/
       - lint:
           requires:
             - setup_dependencies
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 3a3d666e0..1e722a2c4 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -9,7 +9,7 @@ v    If a checkbox is n/a - please still include it but + a little note why
 - [ ] Linked to github-issue with discussion and accepted design OR link to spec that describes this work.
 - [ ] Wrote tests
 - [ ] Updated relevant documentation (`docs/`)
-- [ ] Added entries in `PENDING.md` with issue # 
+- [ ] Added a relevant changelog entry: `sdkch add [section] [stanza] [message]`
 - [ ] rereviewed `Files changed` in the github PR explorer
 
 ______
diff --git a/.gitignore b/.gitignore
index 9f4806524..b6c9df729 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,18 +7,17 @@
 *.swn
 .vscode
 .idea
+*.pyc
 
 # Build
 vendor
-vendor-deps
-.vendor-new
 build
 tools/bin/*
 examples/build/*
 docs/_build
 docs/tutorial
 dist
-devtools-stamp
+tools-stamp
 
 # Data - ideally these don't exist
 baseapp/data/*
diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 000000000..ce8010e7a
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,17 @@
+linters:
+  disable-all: true
+  enable:
+    - errcheck
+    - golint
+    - ineffassign
+    - unconvert
+    - misspell
+linters-settings:
+  gocyclo:
+    min-complexity: 11
+  errcheck:
+    ignore: fmt:.*,io/ioutil:^Read.*,github.com/spf13/cobra:MarkFlagRequired,github.com/spf13/viper:BindPFlag
+  golint:
+    min-confidence: 1.1
+run:
+  tests: false
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f2c61e9a9..ff1081e7c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,153 @@
 # Changelog
 
+* [0.34.0](#0340)
+  * [Breaking Changes](#breaking-changes)
+    * [Gaia](#gaia)
+    * [Gaia CLI](#gaia-cli)
+    * [SDK](#sdk)
+    * [Tendermint](#tendermint)
+  * [New features](#new-features)
+    * [SDK](#sdk-1)
+    * [Gaia](#gaia-1)
+    * [Gaia CLI](#gaia-cli-1)
+    * [Gaia REST API](#gaia-rest-api)
+  * [Improvements](#improvements)
+    * [Gaia](#gaia-2)
+    * [Gaia CLI](#gaia-cli-2)
+    * [SDK](#sdk-2)
+  * [Bug Fixes](#bug-fixes)
+    * [Gaia](#gaia-3)
+    * [Gaia CLI](#gaia-cli-3)
+    * [SDK](#sdk-3)
+* [0.33.2](#0332)
+  * [Improvements](#improvements-1)
+    * [Tendermint](#tendermint-1)
+* [0.33.1](#0331)
+  * [Bug Fixes](#bug-fixes-1)
+    * [Gaia](#gaia-4)
+
+## 0.34.0
+
+### Breaking Changes
+
+#### Gaia
+
+* [\#3463](https://github.com/cosmos/cosmos-sdk/issues/3463) Revert bank module handler fork (re-enables transfers)
+* [\#3875](https://github.com/cosmos/cosmos-sdk/issues/3875) Replace `async` flag with `--broadcast-mode` flag where the default
+  value is `sync`. The `block` mode should not be used. The REST client now
+  uses `mode` parameter instead of the `return` parameter.
+
+#### Gaia CLI
+
+* [\#3938](https://github.com/cosmos/cosmos-sdk/issues/3938) Remove REST server's SSL support altogether.
+
+#### SDK
+
+* [\#3245](https://github.com/cosmos/cosmos-sdk/issues/3245) Rename validator.GetJailed() to validator.IsJailed()
+* [\#3516](https://github.com/cosmos/cosmos-sdk/issues/3516) Remove concept of shares from staking unbonding and redelegation UX;
+  replaced by direct coin amount.
+
+#### Tendermint
+
+* [\#4029](https://github.com/cosmos/cosmos-sdk/issues/4029) Upgrade Tendermint to v0.31.3
+
+### New features
+
+#### SDK
+
+* [\#2935](https://github.com/cosmos/cosmos-sdk/issues/2935) New module Crisis which can test broken invariant with messages
+* [\#3813](https://github.com/cosmos/cosmos-sdk/issues/3813) New sdk.NewCoins safe constructor to replace bare sdk.Coins{} declarations.
+* [\#3858](https://github.com/cosmos/cosmos-sdk/issues/3858) add website, details and identity to gentx cli command
+* Implement coin conversion and denomination registration utilities
+
+#### Gaia
+
+* [\#2935](https://github.com/cosmos/cosmos-sdk/issues/2935) Optionally assert invariants on a blockly basis using `gaiad --assert-invariants-blockly`
+* [\#3886](https://github.com/cosmos/cosmos-sdk/issues/3886) Implement minting module querier and CLI/REST clients.
+
+#### Gaia CLI
+
+* [\#3937](https://github.com/cosmos/cosmos-sdk/issues/3937) Add command to query community-pool
+
+#### Gaia REST API
+
+* [\#3937](https://github.com/cosmos/cosmos-sdk/issues/3937) Add route to fetch community-pool
+* [\#3949](https://github.com/cosmos/cosmos-sdk/issues/3949) added /slashing/signing_infos to get signing_info for all validators
+
+### Improvements
+
+#### Gaia
+
+* [\#3808](https://github.com/cosmos/cosmos-sdk/issues/3808) `gaiad` and `gaiacli` integration tests use ./build/ binaries.
+* \[\#3819](https://github.com/cosmos/cosmos-sdk/issues/3819) Simulation refactor, log output now stored in ~/.gaiad/simulation/
+  * Simulation moved to its own module (not a part of mock)
+  * Logger type instead of passing function variables everywhere
+  * Logger json output (for reloadable simulation running)
+  * Cleanup bank simulation messages / remove dup code in bank simulation
+  * Simulations saved in `~/.gaiad/simulations/`
+  * "Lean" simulation output option to exclude No-ops and !ok functions (`--SimulationLean` flag)
+* [\#3893](https://github.com/cosmos/cosmos-sdk/issues/3893) Improve `gaiacli tx sign` command
+  * Add shorthand flags -a and -s for the account and sequence numbers respectively
+  * Mark the account and sequence numbers required during "offline" mode
+  * Always do an RPC query for account and sequence number during "online" mode
+* [\#4018](https://github.com/cosmos/cosmos-sdk/issues/4018) create genesis port script for release v.0.34.0
+
+#### Gaia CLI
+
+* [\#3833](https://github.com/cosmos/cosmos-sdk/issues/3833) Modify stake to atom in gaia's doc.
+* [\#3841](https://github.com/cosmos/cosmos-sdk/issues/3841) Add indent to JSON of `gaiacli keys [add|show|list]`
+* [\#3859](https://github.com/cosmos/cosmos-sdk/issues/3859) Add newline to echo of `gaiacli keys ...`
+* [\#3959](https://github.com/cosmos/cosmos-sdk/issues/3959) Improving error messages when signing with ledger devices fails
+
+#### SDK
+
+* [\#3238](https://github.com/cosmos/cosmos-sdk/issues/3238) Add block time to tx responses when querying for
+  txs by tags or hash.
+* \[\#3752](https://github.com/cosmos/cosmos-sdk/issues/3752) Explanatory docs for minting mechanism (`docs/spec/mint/01_concepts.md`)
+* [\#3801](https://github.com/cosmos/cosmos-sdk/issues/3801) `baseapp` safety improvements
+* [\#3820](https://github.com/cosmos/cosmos-sdk/issues/3820) Make Coins.IsAllGT() more robust and consistent.
+* [\#3828](https://github.com/cosmos/cosmos-sdk/issues/3828) New sdkch tool to maintain changelogs
+* [\#3864](https://github.com/cosmos/cosmos-sdk/issues/3864) Make Coins.IsAllGTE() more consistent.
+* [\#3907](https://github.com/cosmos/cosmos-sdk/issues/3907): dep -> go mod migration
+  * Drop dep in favor of go modules.
+  * Upgrade to Go 1.12.1.
+* [\#3917](https://github.com/cosmos/cosmos-sdk/issues/3917) Allow arbitrary decreases to validator commission rates.
+* [\#3937](https://github.com/cosmos/cosmos-sdk/issues/3937) Implement community pool querier.
+* [\#3940](https://github.com/cosmos/cosmos-sdk/issues/3940) Codespace should be lowercase.
+* [\#3986](https://github.com/cosmos/cosmos-sdk/issues/3986) Update the Stringer implementation of the Proposal type.
+* [\#926](https://github.com/cosmos/cosmos-sdk/issues/926) circuit breaker high level explanation
+* [\#3896](https://github.com/cosmos/cosmos-sdk/issues/3896) Fixed various linters warnings in the context of the gometalinter -> golangci-lint migration
+* [\#3916](https://github.com/cosmos/cosmos-sdk/issues/3916) Hex encode data in tx responses
+
+### Bug Fixes
+
+#### Gaia
+
+* [\#3825](https://github.com/cosmos/cosmos-sdk/issues/3825) Validate genesis before running gentx
+* [\#3889](https://github.com/cosmos/cosmos-sdk/issues/3889) When `--generate-only` is provided, the Keybase is not used and as a result
+  the `--from` value must be a valid Bech32 cosmos address.
+* 3974 Fix go env setting in installation.md
+* 3996 Change 'make get_tools' to 'make tools' in DOCS_README.md.
+
+#### Gaia CLI
+
+* [\#3883](https://github.com/cosmos/cosmos-sdk/issues/3883) Remove Height Flag from CLI Queries
+* [\#3899](https://github.com/cosmos/cosmos-sdk/issues/3899) Using 'gaiacli config node' breaks ~/config/config.toml
+
+#### SDK
+
+* [\#3837](https://github.com/cosmos/cosmos-sdk/issues/3837) Fix `WithdrawValidatorCommission` to properly set the validator's remaining commission.
+* [\#3870](https://github.com/cosmos/cosmos-sdk/issues/3870) Fix DecCoins#TruncateDecimal to never return zero coins in
+  either the truncated coins or the change coins.
+* [\#3915](https://github.com/cosmos/cosmos-sdk/issues/3915) Remove ';' delimiting support from ParseDecCoins
+* [\#3977](https://github.com/cosmos/cosmos-sdk/issues/3977) Fix docker image build
+* [\#4020](https://github.com/cosmos/cosmos-sdk/issues/4020) Fix queryDelegationRewards by returning an error
+when the validator or delegation do not exist.
+* [\#4050](https://github.com/cosmos/cosmos-sdk/issues/4050) Fix DecCoins APIs
+where rounding or truncation could result in zero decimal coins.
+* [\#4088](https://github.com/cosmos/cosmos-sdk/issues/4088) Fix `calculateDelegationRewards`
+by accounting for rounding errors when multiplying stake by slashing fractions.
+
 ## 0.33.2
 
 ### Improvements
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index bd54c5f02..a6cd69fb4 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -100,21 +100,15 @@ Please don't make Pull Requests to `master`.
 
 ## Dependencies
 
-We use [dep](https://github.com/golang/dep) to manage dependencies.
+We use [Go 1.11 Modules](https://github.com/golang/go/wiki/Modules) to manage
+dependency versions.
 
-That said, the master branch of every Cosmos repository should just build
-with `go get`, which means they should be kept up-to-date with their
-dependencies so we can get away with telling people they can just `go get` our
-software.
+The master branch of every Cosmos repository should just build with `go get`,
+which means they should be kept up-to-date with their dependencies so we can
+get away with telling people they can just `go get` our software.
 
 Since some dependencies are not under our control, a third party may break our
-build, in which case we can fall back on `dep ensure` (or `make
-get_vendor_deps`). Even for dependencies under our control, dep helps us to
-keep multiple repos in sync as they evolve. Anything with an executable, such
-as apps, tools, and the core, should use dep.
-
-Run `dep status` to get a list of vendor dependencies that may not be
-up-to-date.
+build, in which case we can fall back on `go mod tidy -v`.
 
 ## Testing
 
@@ -171,7 +165,7 @@ only pull requests targeted directly against master.
 ### Development Procedure:
   - the latest state of development is on `develop`
   - `develop` must never fail `make test` or `make test_cli`
-  - `develop` should not fail `make test_lint`
+  - `develop` should not fail `make lint`
   - no --force onto `develop` (except when reverting a broken commit, which should seldom happen)
   - create a development branch either on github.com/cosmos/cosmos-sdk, or your fork (using `git remote add origin`)
   - before submitting a pull request, begin `git rebase` on top of `develop`
diff --git a/Dockerfile b/Dockerfile
index aea2ecc9d..517c63589 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -5,7 +5,7 @@
 FROM golang:alpine AS build-env
 
 # Set up dependencies
-ENV PACKAGES make git libc-dev bash gcc linux-headers eudev-dev
+ENV PACKAGES curl make git libc-dev bash gcc linux-headers eudev-dev
 
 # Set working directory for the build
 WORKDIR /go/src/github.com/cosmos/cosmos-sdk
@@ -16,8 +16,6 @@ COPY . .
 # Install minimum necessary dependencies, build Cosmos SDK, remove packages
 RUN apk add --no-cache $PACKAGES && \
     make tools && \
-    make vendor-deps && \
-    make build && \
     make install
 
 # Final image
diff --git a/Gopkg.lock b/Gopkg.lock
deleted file mode 100644
index bae3081ff..000000000
--- a/Gopkg.lock
+++ /dev/null
@@ -1,725 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  branch = "master"
-  digest = "1:09a7f74eb6bb3c0f14d8926610c87f569c5cff68e978d30e9a3540aeb626fdf0"
-  name = "github.com/bartekn/go-bip39"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "a05967ea095d81c8fe4833776774cfaff8e5036c"
-
-[[projects]]
-  branch = "master"
-  digest = "1:d6afaeed1502aa28e80a4ed0981d570ad91b2579193404256ce672ed0a609e0d"
-  name = "github.com/beorn7/perks"
-  packages = ["quantile"]
-  pruneopts = "UT"
-  revision = "3a771d992973f24aa725d07868b467d1ddfceafb"
-
-[[projects]]
-  digest = "1:1343a2963481a305ca4d051e84bc2abd16b601ee22ed324f8d605de1adb291b0"
-  name = "github.com/bgentry/speakeasy"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "4aabc24848ce5fd31929f7d1e4ea74d3709c14cd"
-  version = "v0.1.0"
-
-[[projects]]
-  digest = "1:093bf93a65962e8191e3e8cd8fc6c363f83d43caca9739c906531ba7210a9904"
-  name = "github.com/btcsuite/btcd"
-  packages = ["btcec"]
-  pruneopts = "UT"
-  revision = "ed77733ec07dfc8a513741138419b8d9d3de9d2d"
-
-[[projects]]
-  digest = "1:386de157f7d19259a7f9c81f26ce011223ce0f090353c1152ffdf730d7d10ac2"
-  name = "github.com/btcsuite/btcutil"
-  packages = ["bech32"]
-  pruneopts = "UT"
-  revision = "d4cc87b860166d00d6b5b9e0d3b3d71d6088d4d4"
-
-[[projects]]
-  digest = "1:e8a3550c8786316675ff54ad6f09d265d129c9d986919af7f541afba50d87ce2"
-  name = "github.com/cosmos/go-bip39"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "52158e4697b87de16ed390e1bdaf813e581008fa"
-
-[[projects]]
-  digest = "1:a2b34d1436ac24a0db176f84c015d80438602eeec12f2f8358bb72749711ab52"
-  name = "github.com/cosmos/ledger-cosmos-go"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "e2f595b3b7b222e1cbe9daf89e73e4dcab02d54c"
-  version = "v0.9.8"
-
-[[projects]]
-  digest = "1:a2c1d0e43bd3baaa071d1b9ed72c27d78169b2b269f71c105ac4ba34b1be4a39"
-  name = "github.com/davecgh/go-spew"
-  packages = ["spew"]
-  pruneopts = "UT"
-  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
-  version = "v1.1.0"
-
-[[projects]]
-  digest = "1:fed20bf7f0da387c96d4cfc140a95572e5aba4bb984beb7de910e090ae39849b"
-  name = "github.com/ethereum/go-ethereum"
-  packages = ["crypto/secp256k1"]
-  pruneopts = "UT"
-  revision = "c942700427557e3ff6de3aaf6b916e2f056c1ec2"
-  version = "v1.8.23"
-
-[[projects]]
-  digest = "1:abeb38ade3f32a92943e5be54f55ed6d6e3b6602761d74b4aab4c9dd45c18abd"
-  name = "github.com/fsnotify/fsnotify"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
-  version = "v1.4.7"
-
-[[projects]]
-  digest = "1:fdf5169073fb0ad6dc12a70c249145e30f4058647bea25f0abd48b6d9f228a11"
-  name = "github.com/go-kit/kit"
-  packages = [
-    "log",
-    "log/level",
-    "log/term",
-    "metrics",
-    "metrics/discard",
-    "metrics/internal/lv",
-    "metrics/prometheus",
-  ]
-  pruneopts = "UT"
-  revision = "4dc7be5d2d12881735283bcab7352178e190fc71"
-  version = "v0.6.0"
-
-[[projects]]
-  digest = "1:4062bc6de62d73e2be342243cf138cf499b34d558876db8d9430e2149388a4d8"
-  name = "github.com/go-logfmt/logfmt"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "07c9b44f60d7ffdfb7d8efe1ad539965737836dc"
-  version = "v0.4.0"
-
-[[projects]]
-  digest = "1:586ea76dbd0374d6fb649a91d70d652b7fe0ccffb8910a77468e7702e7901f3d"
-  name = "github.com/go-stack/stack"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "2fee6af1a9795aafbe0253a0cfbdf668e1fb8a9a"
-  version = "v1.8.0"
-
-[[projects]]
-  digest = "1:35621fe20f140f05a0c4ef662c26c0ab4ee50bca78aa30fe87d33120bd28165e"
-  name = "github.com/gogo/protobuf"
-  packages = [
-    "gogoproto",
-    "jsonpb",
-    "proto",
-    "protoc-gen-gogo/descriptor",
-    "sortkeys",
-    "types",
-  ]
-  pruneopts = "UT"
-  revision = "636bf0302bc95575d69441b25a2603156ffdddf1"
-  version = "v1.1.1"
-
-[[projects]]
-  digest = "1:17fe264ee908afc795734e8c4e63db2accabaf57326dbf21763a7d6b86096260"
-  name = "github.com/golang/protobuf"
-  packages = [
-    "proto",
-    "ptypes",
-    "ptypes/any",
-    "ptypes/duration",
-    "ptypes/timestamp",
-  ]
-  pruneopts = "UT"
-  revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265"
-  version = "v1.1.0"
-
-[[projects]]
-  digest = "1:e4f5819333ac698d294fe04dbf640f84719658d5c7ce195b10060cc37292ce79"
-  name = "github.com/golang/snappy"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "2a8bb927dd31d8daada140a5d09578521ce5c36a"
-  version = "v0.0.1"
-
-[[projects]]
-  digest = "1:ca59b1175189b3f0e9f1793d2c350114be36eaabbe5b9f554b35edee1de50aea"
-  name = "github.com/gorilla/mux"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "a7962380ca08b5a188038c69871b8d3fbdf31e89"
-  version = "v1.7.0"
-
-[[projects]]
-  digest = "1:7b5c6e2eeaa9ae5907c391a91c132abfd5c9e8a784a341b5625e750c67e6825d"
-  name = "github.com/gorilla/websocket"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "66b9c49e59c6c48f0ffce28c2d8b8a5678502c6d"
-  version = "v1.4.0"
-
-[[projects]]
-  digest = "1:c0d19ab64b32ce9fe5cf4ddceba78d5bc9807f0016db6b1183599da3dcc24d10"
-  name = "github.com/hashicorp/hcl"
-  packages = [
-    ".",
-    "hcl/ast",
-    "hcl/parser",
-    "hcl/printer",
-    "hcl/scanner",
-    "hcl/strconv",
-    "hcl/token",
-    "json/parser",
-    "json/scanner",
-    "json/token",
-  ]
-  pruneopts = "UT"
-  revision = "8cb6e5b959231cc1119e43259c4a608f9c51a241"
-  version = "v1.0.0"
-
-[[projects]]
-  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
-  name = "github.com/inconshreveable/mousetrap"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
-  version = "v1.0"
-
-[[projects]]
-  digest = "1:a74b5a8e34ee5843cd6e65f698f3e75614f812ff170c2243425d75bc091e9af2"
-  name = "github.com/jmhodges/levigo"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "853d788c5c416eaaee5b044570784a96c7a26975"
-  version = "v1.0.0"
-
-[[projects]]
-  branch = "master"
-  digest = "1:a64e323dc06b73892e5bb5d040ced475c4645d456038333883f58934abbf6f72"
-  name = "github.com/kr/logfmt"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "b84e30acd515aadc4b783ad4ff83aff3299bdfe0"
-
-[[projects]]
-  digest = "1:c568d7727aa262c32bdf8a3f7db83614f7af0ed661474b24588de635c20024c7"
-  name = "github.com/magiconair/properties"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "c2353362d570a7bfa228149c62842019201cfb71"
-  version = "v1.8.0"
-
-[[projects]]
-  digest = "1:3bb9c8451d199650bfd303e0068d86f135952fead374ad87c09a9b8a2cc4bd7c"
-  name = "github.com/mattn/go-isatty"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "369ecd8cea9851e459abb67eb171853e3986591e"
-  version = "v0.0.6"
-
-[[projects]]
-  digest = "1:ff5ebae34cfbf047d505ee150de27e60570e8c394b3b8fdbb720ff6ac71985fc"
-  name = "github.com/matttproud/golang_protobuf_extensions"
-  packages = ["pbutil"]
-  pruneopts = "UT"
-  revision = "c12348ce28de40eed0136aa2b644d0ee0650e56c"
-  version = "v1.0.1"
-
-[[projects]]
-  digest = "1:53bc4cd4914cd7cd52139990d5170d6dc99067ae31c56530621b18b35fc30318"
-  name = "github.com/mitchellh/mapstructure"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "3536a929edddb9a5b34bd6861dc4a9647cb459fe"
-  version = "v1.1.2"
-
-[[projects]]
-  digest = "1:6d4d9067e639d96a804ee9a30fa89c7233c5c5edbfe736072ff00d48c97bccc4"
-  name = "github.com/otiai10/copy"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "7e9a647135a142c2669943d4a4d29be015ce9392"
-
-[[projects]]
-  digest = "1:95741de3af260a92cc5c7f3f3061e85273f5a81b5db20d4bd68da74bd521675e"
-  name = "github.com/pelletier/go-toml"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "c01d1270ff3e442a8a57cddc1c92dc1138598194"
-  version = "v1.2.0"
-
-[[projects]]
-  digest = "1:40e195917a951a8bf867cd05de2a46aaf1806c50cf92eebf4c16f78cd196f747"
-  name = "github.com/pkg/errors"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
-  version = "v0.8.0"
-
-[[projects]]
-  digest = "1:0028cb19b2e4c3112225cd871870f2d9cf49b9b4276531f03438a88e94be86fe"
-  name = "github.com/pmezard/go-difflib"
-  packages = ["difflib"]
-  pruneopts = "UT"
-  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
-  version = "v1.0.0"
-
-[[projects]]
-  digest = "1:93a746f1060a8acbcf69344862b2ceced80f854170e1caae089b2834c5fbf7f4"
-  name = "github.com/prometheus/client_golang"
-  packages = [
-    "prometheus",
-    "prometheus/internal",
-    "prometheus/promhttp",
-  ]
-  pruneopts = "UT"
-  revision = "505eaef017263e299324067d40ca2c48f6a2cf50"
-  version = "v0.9.2"
-
-[[projects]]
-  branch = "master"
-  digest = "1:2d5cd61daa5565187e1d96bae64dbbc6080dacf741448e9629c64fd93203b0d4"
-  name = "github.com/prometheus/client_model"
-  packages = ["go"]
-  pruneopts = "UT"
-  revision = "fd36f4220a901265f90734c3183c5f0c91daa0b8"
-
-[[projects]]
-  digest = "1:35cf6bdf68db765988baa9c4f10cc5d7dda1126a54bd62e252dbcd0b1fc8da90"
-  name = "github.com/prometheus/common"
-  packages = [
-    "expfmt",
-    "internal/bitbucket.org/ww/goautoneg",
-    "model",
-  ]
-  pruneopts = "UT"
-  revision = "cfeb6f9992ffa54aaa4f2170ade4067ee478b250"
-  version = "v0.2.0"
-
-[[projects]]
-  branch = "master"
-  digest = "1:bfc66a1fd78dc8f14d419fd52a5a42db1d572e887ebcc80b98c1a515a8f2d837"
-  name = "github.com/prometheus/procfs"
-  packages = [
-    ".",
-    "internal/util",
-    "iostats",
-    "nfs",
-    "xfs",
-  ]
-  pruneopts = "UT"
-  revision = "bbced9601137e764853b2fad7ec3e2dc4c504e02"
-
-[[projects]]
-  digest = "1:ea0700160aca4ef099f4e06686a665a87691f4248dddd40796925eda2e46bd64"
-  name = "github.com/rakyll/statik"
-  packages = ["fs"]
-  pruneopts = "UT"
-  revision = "aa8a7b1baecd0f31a436bf7956fcdcc609a83035"
-  version = "v0.1.4"
-
-[[projects]]
-  digest = "1:c4556a44e350b50a490544d9b06e9fba9c286c21d6c0e47f54f3a9214597298c"
-  name = "github.com/rcrowley/go-metrics"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "e2704e165165ec55d062f5919b4b29494e9fa790"
-
-[[projects]]
-  digest = "1:b0c25f00bad20d783d259af2af8666969e2fc343fa0dc9efe52936bbd67fb758"
-  name = "github.com/rs/cors"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "9a47f48565a795472d43519dd49aac781f3034fb"
-  version = "v1.6.0"
-
-[[projects]]
-  digest = "1:3e39bafd6c2f4bf3c76c3bfd16a2e09e016510ad5db90dc02b88e2f565d6d595"
-  name = "github.com/spf13/afero"
-  packages = [
-    ".",
-    "mem",
-  ]
-  pruneopts = "UT"
-  revision = "f4711e4db9e9a1d3887343acb72b2bbfc2f686f5"
-  version = "v1.2.1"
-
-[[projects]]
-  digest = "1:08d65904057412fc0270fc4812a1c90c594186819243160dc779a402d4b6d0bc"
-  name = "github.com/spf13/cast"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "8c9545af88b134710ab1cd196795e7f2388358d7"
-  version = "v1.3.0"
-
-[[projects]]
-  digest = "1:645cabccbb4fa8aab25a956cbcbdf6a6845ca736b2c64e197ca7cbb9d210b939"
-  name = "github.com/spf13/cobra"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "ef82de70bb3f60c65fb8eebacbb2d122ef517385"
-  version = "v0.0.3"
-
-[[projects]]
-  digest = "1:1b753ec16506f5864d26a28b43703c58831255059644351bbcb019b843950900"
-  name = "github.com/spf13/jwalterweatherman"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "94f6ae3ed3bceceafa716478c5fbf8d29ca601a1"
-  version = "v1.1.0"
-
-[[projects]]
-  digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2"
-  name = "github.com/spf13/pflag"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
-  version = "v1.0.3"
-
-[[projects]]
-  digest = "1:ba07ec7953d565ac57a11b123a3bf0c8e848f2c7f637fccb0f9ce4f9e489d69a"
-  name = "github.com/spf13/viper"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "a1b837276271029e31f796ae5d03ba9ffb017244"
-  version = "v1.0.3"
-
-[[projects]]
-  digest = "1:7e8d267900c7fa7f35129a2a37596e38ed0f11ca746d6d9ba727980ee138f9f6"
-  name = "github.com/stretchr/testify"
-  packages = [
-    "assert",
-    "require",
-  ]
-  pruneopts = "UT"
-  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
-  version = "v1.2.1"
-
-[[projects]]
-  digest = "1:b3cfb8d82b1601a846417c3f31c03a7961862cb2c98dcf0959c473843e6d9a2b"
-  name = "github.com/syndtr/goleveldb"
-  packages = [
-    "leveldb",
-    "leveldb/cache",
-    "leveldb/comparer",
-    "leveldb/errors",
-    "leveldb/filter",
-    "leveldb/iterator",
-    "leveldb/journal",
-    "leveldb/memdb",
-    "leveldb/opt",
-    "leveldb/storage",
-    "leveldb/table",
-    "leveldb/util",
-  ]
-  pruneopts = "UT"
-  revision = "c4c61651e9e37fa117f53c5a906d3b63090d8445"
-
-[[projects]]
-  digest = "1:83f5e189eea2baad419a6a410984514266ff690075759c87e9ede596809bd0b8"
-  name = "github.com/tendermint/btcd"
-  packages = ["btcec"]
-  pruneopts = "UT"
-  revision = "80daadac05d1cd29571fccf27002d79667a88b58"
-  version = "v0.1.1"
-
-[[projects]]
-  digest = "1:ad9c4c1a4e7875330b1f62906f2830f043a23edb5db997e3a5ac5d3e6eadf80a"
-  name = "github.com/tendermint/go-amino"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "dc14acf9ef15f85828bfbc561ed9dd9d2a284885"
-  version = "v0.14.1"
-
-[[projects]]
-  digest = "1:1bb088f6291e5426e3874a60bca0e481a91a5633395d7e0c427ec3e49b626e7b"
-  name = "github.com/tendermint/iavl"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "ac7c35c12e8633a1e9fd0b52a00b900b40f32cd3"
-  version = "v0.12.1"
-
-[[projects]]
-  digest = "1:97ded93050176418272057abf9819a3dea92713a40327e9906ba6deb92896e9d"
-  name = "github.com/tendermint/tendermint"
-  packages = [
-    "abci/client",
-    "abci/example/code",
-    "abci/example/counter",
-    "abci/example/kvstore",
-    "abci/server",
-    "abci/types",
-    "blockchain",
-    "cmd/tendermint/commands",
-    "config",
-    "consensus",
-    "consensus/types",
-    "crypto",
-    "crypto/armor",
-    "crypto/ed25519",
-    "crypto/encoding/amino",
-    "crypto/merkle",
-    "crypto/multisig",
-    "crypto/multisig/bitarray",
-    "crypto/secp256k1",
-    "crypto/tmhash",
-    "crypto/xsalsa20symmetric",
-    "evidence",
-    "libs/autofile",
-    "libs/bech32",
-    "libs/cli",
-    "libs/cli/flags",
-    "libs/clist",
-    "libs/common",
-    "libs/db",
-    "libs/events",
-    "libs/fail",
-    "libs/flowrate",
-    "libs/log",
-    "libs/pubsub",
-    "libs/pubsub/query",
-    "lite",
-    "lite/client",
-    "lite/errors",
-    "lite/proxy",
-    "mempool",
-    "node",
-    "p2p",
-    "p2p/conn",
-    "p2p/pex",
-    "p2p/upnp",
-    "privval",
-    "proxy",
-    "rpc/client",
-    "rpc/core",
-    "rpc/core/types",
-    "rpc/grpc",
-    "rpc/lib/client",
-    "rpc/lib/server",
-    "rpc/lib/types",
-    "state",
-    "state/txindex",
-    "state/txindex/kv",
-    "state/txindex/null",
-    "types",
-    "types/time",
-    "version",
-  ]
-  pruneopts = "UT"
-  revision = "v0.31.0-dev0-fix0"
-
-[[projects]]
-  digest = "1:b73f5e117bc7c6e8fc47128f20db48a873324ad5cfeeebfc505e85c58682b5e4"
-  name = "github.com/zondax/hid"
-  packages = ["."]
-  pruneopts = "T"
-  revision = "302fd402163c34626286195dfa9adac758334acc"
-  version = "v0.9.0"
-
-[[projects]]
-  digest = "1:f8e4c0b959174a1fa5946b12f1f2ac7ea5651bef20a9e4a8dac55dbffcaa6cd6"
-  name = "github.com/zondax/ledger-go"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "69c15f1333a9b6866e5f66096561c7d138894bc5"
-  version = "v0.8.0"
-
-[[projects]]
-  digest = "1:6f6dc6060c4e9ba73cf28aa88f12a69a030d3d19d518ef8e931879eaa099628d"
-  name = "golang.org/x/crypto"
-  packages = [
-    "bcrypt",
-    "blowfish",
-    "chacha20poly1305",
-    "curve25519",
-    "ed25519",
-    "ed25519/internal/edwards25519",
-    "hkdf",
-    "internal/chacha20",
-    "internal/subtle",
-    "nacl/box",
-    "nacl/secretbox",
-    "openpgp/armor",
-    "openpgp/errors",
-    "pbkdf2",
-    "poly1305",
-    "ripemd160",
-    "salsa20/salsa",
-  ]
-  pruneopts = "UT"
-  revision = "3764759f34a542a3aef74d6b02e35be7ab893bba"
-  source = "https://github.com/tendermint/crypto"
-
-[[projects]]
-  digest = "1:d36f55a999540d29b6ea3c2ea29d71c76b1d9853fdcd3e5c5cb4836f2ba118f1"
-  name = "golang.org/x/net"
-  packages = [
-    "context",
-    "http/httpguts",
-    "http2",
-    "http2/hpack",
-    "idna",
-    "internal/timeseries",
-    "netutil",
-    "trace",
-  ]
-  pruneopts = "UT"
-  revision = "292b43bbf7cb8d35ddf40f8d5100ef3837cced3f"
-
-[[projects]]
-  digest = "1:4bd75b1a219bc590b05c976bbebf47f4e993314ebb5c7cbf2efe05a09a184d54"
-  name = "golang.org/x/sys"
-  packages = [
-    "cpu",
-    "unix",
-  ]
-  pruneopts = "UT"
-  revision = "4e1fef5609515ec7a2cee7b5de30ba6d9b438cbf"
-
-[[projects]]
-  digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
-  name = "golang.org/x/text"
-  packages = [
-    "collate",
-    "collate/build",
-    "internal/colltab",
-    "internal/gen",
-    "internal/tag",
-    "internal/triegen",
-    "internal/ucd",
-    "language",
-    "secure/bidirule",
-    "transform",
-    "unicode/bidi",
-    "unicode/cldr",
-    "unicode/norm",
-    "unicode/rangetable",
-  ]
-  pruneopts = "UT"
-  revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
-  version = "v0.3.0"
-
-[[projects]]
-  digest = "1:077c1c599507b3b3e9156d17d36e1e61928ee9b53a5b420f10f28ebd4a0b275c"
-  name = "google.golang.org/genproto"
-  packages = ["googleapis/rpc/status"]
-  pruneopts = "UT"
-  revision = "383e8b2c3b9e36c4076b235b32537292176bae20"
-
-[[projects]]
-  digest = "1:cbc746de4662c66fd24a037501bd65aa0f8ad0bfca0c92576e0abb88864e3741"
-  name = "google.golang.org/grpc"
-  packages = [
-    ".",
-    "balancer",
-    "balancer/base",
-    "balancer/roundrobin",
-    "binarylog/grpc_binarylog_v1",
-    "codes",
-    "connectivity",
-    "credentials",
-    "credentials/internal",
-    "encoding",
-    "encoding/proto",
-    "grpclog",
-    "internal",
-    "internal/backoff",
-    "internal/binarylog",
-    "internal/channelz",
-    "internal/envconfig",
-    "internal/grpcrand",
-    "internal/grpcsync",
-    "internal/syscall",
-    "internal/transport",
-    "keepalive",
-    "metadata",
-    "naming",
-    "peer",
-    "resolver",
-    "resolver/dns",
-    "resolver/passthrough",
-    "stats",
-    "status",
-    "tap",
-  ]
-  pruneopts = "UT"
-  revision = "2fdaae294f38ed9a121193c51ec99fecd3b13eb7"
-  version = "v1.19.0"
-
-[[projects]]
-  digest = "1:4d2e5a73dc1500038e504a8d78b986630e3626dc027bc030ba5c75da257cdb96"
-  name = "gopkg.in/yaml.v2"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "51d6538a90f86fe93ac480b35f37b2be17fef232"
-  version = "v2.2.2"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  input-imports = [
-    "github.com/bartekn/go-bip39",
-    "github.com/bgentry/speakeasy",
-    "github.com/btcsuite/btcd/btcec",
-    "github.com/cosmos/go-bip39",
-    "github.com/cosmos/ledger-cosmos-go",
-    "github.com/gogo/protobuf/proto",
-    "github.com/golang/protobuf/proto",
-    "github.com/gorilla/mux",
-    "github.com/mattn/go-isatty",
-    "github.com/otiai10/copy",
-    "github.com/pelletier/go-toml",
-    "github.com/pkg/errors",
-    "github.com/rakyll/statik/fs",
-    "github.com/spf13/cobra",
-    "github.com/spf13/pflag",
-    "github.com/spf13/viper",
-    "github.com/stretchr/testify/assert",
-    "github.com/stretchr/testify/require",
-    "github.com/tendermint/btcd/btcec",
-    "github.com/tendermint/go-amino",
-    "github.com/tendermint/iavl",
-    "github.com/tendermint/tendermint/abci/server",
-    "github.com/tendermint/tendermint/abci/types",
-    "github.com/tendermint/tendermint/blockchain",
-    "github.com/tendermint/tendermint/cmd/tendermint/commands",
-    "github.com/tendermint/tendermint/config",
-    "github.com/tendermint/tendermint/crypto",
-    "github.com/tendermint/tendermint/crypto/armor",
-    "github.com/tendermint/tendermint/crypto/ed25519",
-    "github.com/tendermint/tendermint/crypto/encoding/amino",
-    "github.com/tendermint/tendermint/crypto/merkle",
-    "github.com/tendermint/tendermint/crypto/multisig",
-    "github.com/tendermint/tendermint/crypto/secp256k1",
-    "github.com/tendermint/tendermint/crypto/tmhash",
-    "github.com/tendermint/tendermint/crypto/xsalsa20symmetric",
-    "github.com/tendermint/tendermint/libs/bech32",
-    "github.com/tendermint/tendermint/libs/cli",
-    "github.com/tendermint/tendermint/libs/cli/flags",
-    "github.com/tendermint/tendermint/libs/common",
-    "github.com/tendermint/tendermint/libs/db",
-    "github.com/tendermint/tendermint/libs/log",
-    "github.com/tendermint/tendermint/lite",
-    "github.com/tendermint/tendermint/lite/errors",
-    "github.com/tendermint/tendermint/lite/proxy",
-    "github.com/tendermint/tendermint/node",
-    "github.com/tendermint/tendermint/p2p",
-    "github.com/tendermint/tendermint/privval",
-    "github.com/tendermint/tendermint/proxy",
-    "github.com/tendermint/tendermint/rpc/client",
-    "github.com/tendermint/tendermint/rpc/core/types",
-    "github.com/tendermint/tendermint/rpc/lib/client",
-    "github.com/tendermint/tendermint/rpc/lib/server",
-    "github.com/tendermint/tendermint/state",
-    "github.com/tendermint/tendermint/types",
-    "github.com/tendermint/tendermint/types/time",
-    "github.com/tendermint/tendermint/version",
-    "golang.org/x/crypto/bcrypt",
-  ]
-  solver-name = "gps-cdcl"
-  solver-version = 1
diff --git a/Gopkg.toml b/Gopkg.toml
deleted file mode 100644
index 565ba42ba..000000000
--- a/Gopkg.toml
+++ /dev/null
@@ -1,93 +0,0 @@
-[[constraint]]
-  name = "github.com/bgentry/speakeasy"
-  version = "~0.1.0"
-
-[[override]]
-  name = "github.com/golang/protobuf"
-  version = "=1.1.0"
-
-[[constraint]]
-  name = "github.com/mattn/go-isatty"
-  version = "~0.0.3"
-
-[[constraint]]
-  name = "github.com/spf13/cobra"
-  version = "~0.0.1"
-
-[[constraint]]
-  name = "github.com/spf13/viper"
-  version = "~1.0.0"
-
-[[constraint]]
-  name = "github.com/pkg/errors"
-  version = "=0.8.0"
-
-[[constraint]]
-  name = "github.com/stretchr/testify"
-  version = "=1.2.1"
-
-[[constraint]]
-  name = "github.com/otiai10/copy"
-  revision = "7e9a647135a142c2669943d4a4d29be015ce9392"
-
-[[override]]
-  name = "github.com/tendermint/go-amino"
-  version = "v0.14.1"
-
-[[override]]
-  name = "github.com/tendermint/iavl"
-  version = "~v0.12.0"
-
-[[override]]
-  name = "github.com/tendermint/tendermint"
-  revision = "v0.31.0-dev0-fix0"
-
-[[constraint]]
-  name = "github.com/cosmos/ledger-cosmos-go"
-  version = "=v0.9.8"
-
-## deps without releases:
-
-[[constraint]]
-  name = "github.com/btcsuite/btcd"
-  revision = "ed77733ec07dfc8a513741138419b8d9d3de9d2d"
-
-[[override]]
-  name = "golang.org/x/crypto"
-  source = "https://github.com/tendermint/crypto"
-  revision = "3764759f34a542a3aef74d6b02e35be7ab893bba"
-
-[[constraint]]
-  name = "github.com/cosmos/go-bip39"
-  revision = "52158e4697b87de16ed390e1bdaf813e581008fa"
-
-## transitive deps, with releases:
-
-[[override]]
-  name = "github.com/davecgh/go-spew"
-  version = "=v1.1.0"
-
-[[constraint]]
-  name = "github.com/rakyll/statik"
-  version = "=v0.1.4"
-
-## transitive deps, without releases:
-
-[[override]]
-  name = "github.com/syndtr/goleveldb"
-  revision = "c4c61651e9e37fa117f53c5a906d3b63090d8445"
-
-[[override]]
-  name = "golang.org/x/sys"
-  revision = "4e1fef5609515ec7a2cee7b5de30ba6d9b438cbf"
-
-[[override]]
-  name = "google.golang.org/genproto"
-  revision = "383e8b2c3b9e36c4076b235b32537292176bae20"
-
-[prune]
-  go-tests = true
-  unused-packages = true
-  [[prune.project]]
-      name = "github.com/zondax/hid"
-      unused-packages = false
diff --git a/Makefile b/Makefile
index d939fde1c..456f19cdd 100644
--- a/Makefile
+++ b/Makefile
@@ -4,11 +4,10 @@ VERSION := $(shell echo $(shell git describe --tags) | sed 's/^v//')
 COMMIT := $(shell git log -1 --format='%H')
 CAT := $(if $(filter $(OS),Windows_NT),type,cat)
 LEDGER_ENABLED ?= true
-GOTOOLS = \
-	github.com/golang/dep/cmd/dep \
-	github.com/alecthomas/gometalinter \
-	github.com/rakyll/statik
 GOBIN ?= $(GOPATH)/bin
+GOSUM := $(shell which gosum)
+
+export GO111MODULE = on
 
 # process build tags
 
@@ -46,9 +45,12 @@ build_tags := $(strip $(build_tags))
 
 ldflags = -X github.com/cosmos/cosmos-sdk/version.Version=$(VERSION) \
 	-X github.com/cosmos/cosmos-sdk/version.Commit=$(COMMIT) \
-  -X github.com/cosmos/cosmos-sdk/version.VendorDirHash=$(shell $(CAT) vendor-deps) \
   -X "github.com/cosmos/cosmos-sdk/version.BuildTags=$(build_tags)"
 
+ifneq ($(GOSUM),)
+ldflags += -X github.com/cosmos/cosmos-sdk/version.VendorDirHash=$(shell $(GOSUM) go.sum)
+endif
+
 ifeq ($(WITH_CLEVELDB),yes)
   ldflags += -X github.com/cosmos/cosmos-sdk/types.DBBackend=cleveldb
 endif
@@ -57,7 +59,7 @@ ldflags := $(strip $(ldflags))
 
 BUILD_FLAGS := -tags "$(build_tags)" -ldflags '$(ldflags)'
 
-all: devtools vendor-deps install test_lint test
+all: tools install lint test
 
 # The below include contains the tools target.
 include scripts/Makefile
@@ -65,36 +67,36 @@ include scripts/Makefile
 ########################################
 ### CI
 
-ci: devtools vendor-deps install test_cover test_lint test
+ci: tools install test_cover lint test
 
 ########################################
 ### Build/Install
 
-build:
+build: go.sum
 ifeq ($(OS),Windows_NT)
-	go build $(BUILD_FLAGS) -o build/gaiad.exe ./cmd/gaia/cmd/gaiad
-	go build $(BUILD_FLAGS) -o build/gaiacli.exe ./cmd/gaia/cmd/gaiacli
+	go build -mod=readonly $(BUILD_FLAGS) -o build/gaiad.exe ./cmd/gaia/cmd/gaiad
+	go build -mod=readonly $(BUILD_FLAGS) -o build/gaiacli.exe ./cmd/gaia/cmd/gaiacli
 else
-	go build $(BUILD_FLAGS) -o build/gaiad ./cmd/gaia/cmd/gaiad
-	go build $(BUILD_FLAGS) -o build/gaiacli ./cmd/gaia/cmd/gaiacli
-	go build $(BUILD_FLAGS) -o build/gaiareplay ./cmd/gaia/cmd/gaiareplay
-	go build $(BUILD_FLAGS) -o build/gaiakeyutil ./cmd/gaia/cmd/gaiakeyutil
+	go build -mod=readonly $(BUILD_FLAGS) -o build/gaiad ./cmd/gaia/cmd/gaiad
+	go build -mod=readonly $(BUILD_FLAGS) -o build/gaiacli ./cmd/gaia/cmd/gaiacli
+	go build -mod=readonly $(BUILD_FLAGS) -o build/gaiareplay ./cmd/gaia/cmd/gaiareplay
+	go build -mod=readonly $(BUILD_FLAGS) -o build/gaiakeyutil ./cmd/gaia/cmd/gaiakeyutil
 endif
 
-build-linux: vendor-deps
+build-linux: go.sum
 	LEDGER_ENABLED=false GOOS=linux GOARCH=amd64 $(MAKE) build
 
 update_gaia_lite_docs:
 	@statik -src=client/lcd/swagger-ui -dest=client/lcd -f
 
-install: vendor-deps check-ledger update_gaia_lite_docs
-	go install $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiad
-	go install $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiacli
-	go install $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiareplay
-	go install $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiakeyutil
+install: go.sum check-ledger update_gaia_lite_docs
+	go install -mod=readonly $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiad
+	go install -mod=readonly $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiacli
+	go install -mod=readonly $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiareplay
+	go install -mod=readonly $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiakeyutil
 
-install_debug:
-	go install $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiadebug
+install_debug: go.sum
+	go install -mod=readonly $(BUILD_FLAGS) ./cmd/gaia/cmd/gaiadebug
 
 dist:
 	@bash publish/dist.sh
@@ -103,38 +105,13 @@ dist:
 ########################################
 ### Tools & dependencies
 
-check_tools:
-	@# https://stackoverflow.com/a/25668869
-	@echo "Found tools: $(foreach tool,$(notdir $(GOTOOLS)),\
-        $(if $(shell which $(tool)),$(tool),$(error "No $(tool) in PATH")))"
+go-mod-cache: go.sum
+	@echo "--> Download go modules to local cache"
+	@go mod download
 
-update_tools:
-	@echo "--> Updating tools to correct version"
-	$(MAKE) --always-make tools
-
-update_dev_tools:
-	@echo "--> Downloading linters (this may take awhile)"
-	$(GOPATH)/src/github.com/alecthomas/gometalinter/scripts/install.sh -b $(GOBIN)
-	go get -u github.com/tendermint/lint/golint
-
-devtools: devtools-stamp
-devtools-clean: tools-clean
-devtools-stamp: tools
-	@echo "--> Downloading linters (this may take awhile)"
-	$(GOPATH)/src/github.com/alecthomas/gometalinter/scripts/install.sh -b $(GOBIN)
-	go get github.com/tendermint/lint/golint
-	touch $@
-
-vendor-deps: tools
-	@echo "--> Generating vendor directory via dep ensure"
-	@rm -rf .vendor-new
-	@dep ensure -v -vendor-only
-	tar -c vendor/ | sha1sum | cut -d' ' -f1 > $@
-
-update_vendor_deps: tools
-	@echo "--> Running dep ensure"
-	@rm -rf .vendor-new
-	@dep ensure -v
+go.sum: tools go.mod
+	@echo "--> Ensure dependencies have not been modified"
+	@go mod verify
 
 draw_deps: tools
 	@# requires brew install graphviz or apt-get install graphviz
@@ -142,7 +119,7 @@ draw_deps: tools
 	@goviz -i github.com/cosmos/cosmos-sdk/cmd/gaia/cmd/gaiad -d 2 | dot -Tpng -o dependency-graph.png
 
 clean:
-	rm -f devtools-stamp vendor-deps snapcraft-local.yaml
+	rm -rf snapcraft-local.yaml build/
 
 distclean: clean
 	rm -rf vendor/
@@ -160,34 +137,34 @@ godocs:
 
 test: test_unit
 
-test_cli:
-	@go test -p 4 `go list github.com/cosmos/cosmos-sdk/cmd/gaia/cli_test` -tags=cli_test
+test_cli: build
+	@go test -mod=readonly -p 4 `go list ./cmd/gaia/cli_test/...` -tags=cli_test
 
 test_ledger:
     # First test with mock
-	@go test `go list github.com/cosmos/cosmos-sdk/crypto` -tags='cgo ledger test_ledger_mock'
+	@go test -mod=readonly `go list github.com/cosmos/cosmos-sdk/crypto` -tags='cgo ledger test_ledger_mock'
     # Now test with a real device
-	@go test -v `go list github.com/cosmos/cosmos-sdk/crypto` -tags='cgo ledger'
+	@go test -mod=readonly -v `go list github.com/cosmos/cosmos-sdk/crypto` -tags='cgo ledger'
 
 test_unit:
-	@VERSION=$(VERSION) go test $(PACKAGES_NOSIMULATION) -tags='ledger test_ledger_mock'
+	@VERSION=$(VERSION) go test -mod=readonly $(PACKAGES_NOSIMULATION) -tags='ledger test_ledger_mock'
 
 test_race:
-	@VERSION=$(VERSION) go test -race $(PACKAGES_NOSIMULATION)
+	@VERSION=$(VERSION) go test -mod=readonly -race $(PACKAGES_NOSIMULATION)
 
 test_sim_gaia_nondeterminism:
 	@echo "Running nondeterminism test..."
-	@go test ./cmd/gaia/app -run TestAppStateDeterminism -SimulationEnabled=true -v -timeout 10m
+	@go test -mod=readonly ./cmd/gaia/app -run TestAppStateDeterminism -SimulationEnabled=true -v -timeout 10m
 
 test_sim_gaia_custom_genesis_fast:
 	@echo "Running custom genesis simulation..."
 	@echo "By default, ${HOME}/.gaiad/config/genesis.json will be used."
-	@go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationGenesis=${HOME}/.gaiad/config/genesis.json \
+	@go test -mod=readonly ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationGenesis=${HOME}/.gaiad/config/genesis.json \
 		-SimulationEnabled=true -SimulationNumBlocks=100 -SimulationBlockSize=200 -SimulationCommit=true -SimulationSeed=99 -SimulationPeriod=5 -v -timeout 24h
 
 test_sim_gaia_fast:
 	@echo "Running quick Gaia simulation. This may take several minutes..."
-	@go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationNumBlocks=100 -SimulationBlockSize=200 -SimulationCommit=true -SimulationSeed=99 -SimulationPeriod=5 -v -timeout 24h
+	@go test -mod=readonly ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationNumBlocks=100 -SimulationBlockSize=200 -SimulationCommit=true -SimulationSeed=99 -SimulationPeriod=5 -v -timeout 24h
 
 test_sim_gaia_import_export:
 	@echo "Running Gaia import/export simulation. This may take several minutes..."
@@ -211,31 +188,31 @@ SIM_BLOCK_SIZE ?= 200
 SIM_COMMIT ?= true
 test_sim_gaia_benchmark:
 	@echo "Running Gaia benchmark for numBlocks=$(SIM_NUM_BLOCKS), blockSize=$(SIM_BLOCK_SIZE). This may take awhile!"
-	@go test -benchmem -run=^$$ github.com/cosmos/cosmos-sdk/cmd/gaia/app -bench ^BenchmarkFullGaiaSimulation$$  \
+	@go test -mod=readonly -benchmem -run=^$$ github.com/cosmos/cosmos-sdk/cmd/gaia/app -bench ^BenchmarkFullGaiaSimulation$$  \
 		-SimulationEnabled=true -SimulationNumBlocks=$(SIM_NUM_BLOCKS) -SimulationBlockSize=$(SIM_BLOCK_SIZE) -SimulationCommit=$(SIM_COMMIT) -timeout 24h
 
 test_sim_gaia_profile:
 	@echo "Running Gaia benchmark for numBlocks=$(SIM_NUM_BLOCKS), blockSize=$(SIM_BLOCK_SIZE). This may take awhile!"
-	@go test -benchmem -run=^$$ github.com/cosmos/cosmos-sdk/cmd/gaia/app -bench ^BenchmarkFullGaiaSimulation$$ \
+	@go test -mod=readonly -benchmem -run=^$$ github.com/cosmos/cosmos-sdk/cmd/gaia/app -bench ^BenchmarkFullGaiaSimulation$$ \
 		-SimulationEnabled=true -SimulationNumBlocks=$(SIM_NUM_BLOCKS) -SimulationBlockSize=$(SIM_BLOCK_SIZE) -SimulationCommit=$(SIM_COMMIT) -timeout 24h -cpuprofile cpu.out -memprofile mem.out
 
 test_cover:
 	@export VERSION=$(VERSION); bash -x tests/test_cover.sh
 
-test_lint:
-	gometalinter --config=tools/gometalinter.json ./...
-	!(gometalinter --exclude /usr/lib/go/src/ --exclude client/lcd/statik/statik.go --exclude 'vendor/*' --disable-all --enable='errcheck' --vendor ./... | grep -v "client/")
+lint: tools ci-lint
+ci-lint:
+	golangci-lint run
+	go vet -composites=false -tests=false ./...
 	find . -name '*.go' -type f -not -path "./vendor*" -not -path "*.git*" | xargs gofmt -d -s
-	dep status >> /dev/null
-	!(grep -n branch Gopkg.toml)
+	go mod verify
 
-format:
+format: tools
 	find . -name '*.go' -type f -not -path "./vendor*" -not -path "*.git*" -not -path "./client/lcd/statik/statik.go" | xargs gofmt -w -s
 	find . -name '*.go' -type f -not -path "./vendor*" -not -path "*.git*" -not -path "./client/lcd/statik/statik.go" | xargs misspell -w
 	find . -name '*.go' -type f -not -path "./vendor*" -not -path "*.git*" -not -path "./client/lcd/statik/statik.go" | xargs goimports -w -local github.com/cosmos/cosmos-sdk
 
 benchmark:
-	@go test -bench=. $(PACKAGES_NOSIMULATION)
+	@go test -mod=readonly -bench=. $(PACKAGES_NOSIMULATION)
 
 
 ########################################
@@ -287,11 +264,11 @@ snapcraft-local.yaml: snapcraft-local.yaml.in
 # To avoid unintended conflicts with file names, always add to .PHONY
 # unless there is a reason not to.
 # https://www.gnu.org/software/make/manual/html_node/Phony-Targets.html
-.PHONY: build install install_debug dist clean distclean \
-check_tools check_dev_tools get_vendor_deps draw_deps test test_cli test_unit \
-test_cover test_lint benchmark devdoc_init devdoc devdoc_save devdoc_update \
+.PHONY: install install_debug dist clean distclean \
+draw_deps test test_cli test_unit \
+test_cover lint benchmark devdoc_init devdoc devdoc_save devdoc_update \
 build-linux build-docker-gaiadnode localnet-start localnet-stop \
 format check-ledger test_sim_gaia_nondeterminism test_sim_modules test_sim_gaia_fast \
 test_sim_gaia_custom_genesis_fast test_sim_gaia_custom_genesis_multi_seed \
-test_sim_gaia_multi_seed test_sim_gaia_import_export update_tools update_dev_tools \
-devtools-clean
+test_sim_gaia_multi_seed test_sim_gaia_import_export \
+go-mod-cache
diff --git a/PENDING.md b/PENDING.md
deleted file mode 100644
index 591311315..000000000
--- a/PENDING.md
+++ /dev/null
@@ -1,57 +0,0 @@
-# PENDING CHANGELOG
-
-<!----------------------------- BREAKING CHANGES ----------------------------->
-
-## BREAKING CHANGES
-
-### Gaia REST API
-
-### Gaia CLI
-
-### Gaia
-
-### SDK
-
-### Tendermint
-
-<!--------------------------------- FEATURES --------------------------------->
-
-## FEATURES
-
-### Gaia REST API
-
-### Gaia CLI
-
-### Gaia
-
-### SDK
-
-### Tendermint
-
-<!------------------------------- IMPROVEMENTS ------------------------------->
-
-## IMPROVEMENTS
-
-### Gaia REST API
-
-### Gaia CLI
-
-### Gaia
-
-### SDK
-
-### Tendermint
-
-<!--------------------------------- BUG FIXES -------------------------------->
-
-## BUG FIXES
-
-### Gaia REST API
-
-### Gaia CLI
-
-### Gaia
-
-### SDK
-
-### Tendermint
diff --git a/README.md b/README.md
index 37b5c4101..f216f2cd6 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ It is being used to build `Gaia`, the first implementation of the Cosmos Hub.
 **WARNING**: The SDK has mostly stabilized, but we are still making some
 breaking changes.
 
-**Note**: Requires [Go 1.11.5+](https://golang.org/dl/)
+**Note**: Requires [Go 1.12.1+](https://golang.org/dl/)
 
 ## Cosmos Hub Mainnet
 
diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go
index b6694a503..b244a98b7 100644
--- a/baseapp/baseapp.go
+++ b/baseapp/baseapp.go
@@ -287,12 +287,25 @@ func (app *BaseApp) storeConsensusParams(consensusParams *abci.ConsensusParams)
 	mainStore.Set(mainConsensusParamsKey, consensusParamsBz)
 }
 
-// getMaximumBlockGas gets the maximum gas from the consensus params.
-func (app *BaseApp) getMaximumBlockGas() (maxGas uint64) {
-	if app.consensusParams == nil || app.consensusParams.BlockSize == nil {
+// getMaximumBlockGas gets the maximum gas from the consensus params. It panics
+// if maximum block gas is less than negative one and returns zero if negative
+// one.
+func (app *BaseApp) getMaximumBlockGas() uint64 {
+	if app.consensusParams == nil || app.consensusParams.Block == nil {
 		return 0
 	}
-	return uint64(app.consensusParams.BlockSize.MaxGas)
+
+	maxGas := app.consensusParams.Block.MaxGas
+	switch {
+	case maxGas < -1:
+		panic(fmt.Sprintf("invalid maximum block gas: %d", maxGas))
+
+	case maxGas == -1:
+		return 0
+
+	default:
+		return uint64(maxGas)
+	}
 }
 
 // ----------------------------------------------------------------------------
@@ -510,6 +523,19 @@ func handleQueryCustom(app *BaseApp, path []string, req abci.RequestQuery) (res
 	}
 }
 
+func (app *BaseApp) validateHeight(req abci.RequestBeginBlock) error {
+	if req.Header.Height < 1 {
+		return fmt.Errorf("invalid height: %d", req.Header.Height)
+	}
+
+	prevHeight := app.LastBlockHeight()
+	if req.Header.Height != prevHeight+1 {
+		return fmt.Errorf("invalid height: %d; expected: %d", req.Header.Height, prevHeight+1)
+	}
+
+	return nil
+}
+
 // BeginBlock implements the ABCI application interface.
 func (app *BaseApp) BeginBlock(req abci.RequestBeginBlock) (res abci.ResponseBeginBlock) {
 	if app.cms.TracingEnabled() {
@@ -518,6 +544,10 @@ func (app *BaseApp) BeginBlock(req abci.RequestBeginBlock) (res abci.ResponseBeg
 		))
 	}
 
+	if err := app.validateHeight(req); err != nil {
+		panic(err)
+	}
+
 	// Initialize the DeliverTx state. If this is the first block, it should
 	// already be initialized in InitChain. Otherwise app.deliverState will be
 	// nil, since it is reset on Commit.
@@ -631,7 +661,7 @@ func (app *BaseApp) getContextForTx(mode runTxMode, txBytes []byte) (ctx sdk.Con
 
 // runMsgs iterates through all the messages and executes them.
 func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg, mode runTxMode) (result sdk.Result) {
-	idxlogs := make([]sdk.ABCIMessageLog, 0, len(msgs)) // a list of JSON-encoded logs with msg index
+	idxLogs := make([]sdk.ABCIMessageLog, 0, len(msgs)) // a list of JSON-encoded logs with msg index
 
 	var data []byte   // NOTE: we just append them all (?!)
 	var tags sdk.Tags // also just append them all
@@ -665,7 +695,7 @@ func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg, mode runTxMode) (re
 		// stop execution and return on first failed message
 		if !msgResult.IsOK() {
 			idxLog.Success = false
-			idxlogs = append(idxlogs, idxLog)
+			idxLogs = append(idxLogs, idxLog)
 
 			code = msgResult.Code
 			codespace = msgResult.Codespace
@@ -673,10 +703,10 @@ func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg, mode runTxMode) (re
 		}
 
 		idxLog.Success = true
-		idxlogs = append(idxlogs, idxLog)
+		idxLogs = append(idxLogs, idxLog)
 	}
 
-	logJSON := codec.Cdc.MustMarshalJSON(idxlogs)
+	logJSON := codec.Cdc.MustMarshalJSON(idxLogs)
 	result = sdk.Result{
 		Code:      code,
 		Codespace: codespace,
@@ -689,7 +719,7 @@ func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg, mode runTxMode) (re
 	return result
 }
 
-// Returns the applicantion's deliverState if app is in runTxModeDeliver,
+// Returns the applications's deliverState if app is in runTxModeDeliver,
 // otherwise it returns the application's checkstate.
 func (app *BaseApp) getState(mode runTxMode) *state {
 	if mode == runTxModeCheck || mode == runTxModeSimulate {
@@ -799,7 +829,7 @@ func (app *BaseApp) runTx(mode runTxMode, txBytes []byte, tx sdk.Tx) (result sdk
 		// performance benefits, but it'll be more difficult to get right.
 		anteCtx, msCache = app.cacheTxContext(ctx, txBytes)
 
-		newCtx, result, abort := app.anteHandler(anteCtx, tx, (mode == runTxModeSimulate))
+		newCtx, result, abort := app.anteHandler(anteCtx, tx, mode == runTxModeSimulate)
 		if !newCtx.IsZero() {
 			// At this point, newCtx.MultiStore() is cache-wrapped, or something else
 			// replaced by the ante handler. We want the original multistore, not one
diff --git a/baseapp/baseapp_test.go b/baseapp/baseapp_test.go
index c1fca6f91..c3d435f9f 100644
--- a/baseapp/baseapp_test.go
+++ b/baseapp/baseapp_test.go
@@ -296,6 +296,7 @@ func TestInitChainer(t *testing.T) {
 	// stores are mounted and private members are set - sealing baseapp
 	err := app.LoadLatestVersion(capKey) // needed to make stores non-nil
 	require.Nil(t, err)
+	require.Equal(t, int64(0), app.LastBlockHeight())
 
 	app.InitChain(abci.RequestInitChain{AppStateBytes: []byte("{}"), ChainId: "test-chain-id"}) // must have valid JSON genesis file, even if empty
 
@@ -308,6 +309,7 @@ func TestInitChainer(t *testing.T) {
 
 	app.Commit()
 	res = app.Query(query)
+	require.Equal(t, int64(1), app.LastBlockHeight())
 	require.Equal(t, value, res.Value)
 
 	// reload app
@@ -316,14 +318,17 @@ func TestInitChainer(t *testing.T) {
 	app.MountStores(capKey, capKey2)
 	err = app.LoadLatestVersion(capKey) // needed to make stores non-nil
 	require.Nil(t, err)
+	require.Equal(t, int64(1), app.LastBlockHeight())
 
 	// ensure we can still query after reloading
 	res = app.Query(query)
 	require.Equal(t, value, res.Value)
 
 	// commit and ensure we can still query
-	app.BeginBlock(abci.RequestBeginBlock{})
+	header := abci.Header{Height: app.LastBlockHeight() + 1}
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
 	app.Commit()
+
 	res = app.Query(query)
 	require.Equal(t, value, res.Value)
 }
@@ -514,7 +519,6 @@ func TestCheckTx(t *testing.T) {
 	app := setupBaseApp(t, anteOpt, routerOpt)
 
 	nTxs := int64(5)
-
 	app.InitChain(abci.RequestInitChain{})
 
 	// Create same codec used in txDecoder
@@ -536,7 +540,8 @@ func TestCheckTx(t *testing.T) {
 	require.Equal(t, nTxs, storedCounter)
 
 	// If a block is committed, CheckTx state should be reset.
-	app.BeginBlock(abci.RequestBeginBlock{})
+	header := abci.Header{Height: 1}
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
 	app.EndBlock(abci.RequestEndBlock{})
 	app.Commit()
 
@@ -567,16 +572,22 @@ func TestDeliverTx(t *testing.T) {
 
 	nBlocks := 3
 	txPerHeight := 5
+
 	for blockN := 0; blockN < nBlocks; blockN++ {
-		app.BeginBlock(abci.RequestBeginBlock{})
+		header := abci.Header{Height: int64(blockN) + 1}
+		app.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 		for i := 0; i < txPerHeight; i++ {
 			counter := int64(blockN*txPerHeight + i)
 			tx := newTxCounter(counter, counter)
+
 			txBytes, err := codec.MarshalBinaryLengthPrefixed(tx)
 			require.NoError(t, err)
+
 			res := app.DeliverTx(txBytes)
 			require.True(t, res.IsOK(), fmt.Sprintf("%v", res))
 		}
+
 		app.EndBlock(abci.RequestEndBlock{})
 		app.Commit()
 	}
@@ -610,48 +621,47 @@ func TestMultiMsgDeliverTx(t *testing.T) {
 
 	// run a multi-msg tx
 	// with all msgs the same route
-	{
-		app.BeginBlock(abci.RequestBeginBlock{})
-		tx := newTxCounter(0, 0, 1, 2)
-		txBytes, err := codec.MarshalBinaryLengthPrefixed(tx)
-		require.NoError(t, err)
-		res := app.DeliverTx(txBytes)
-		require.True(t, res.IsOK(), fmt.Sprintf("%v", res))
 
-		store := app.deliverState.ctx.KVStore(capKey1)
+	header := abci.Header{Height: 1}
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
+	tx := newTxCounter(0, 0, 1, 2)
+	txBytes, err := codec.MarshalBinaryLengthPrefixed(tx)
+	require.NoError(t, err)
+	res := app.DeliverTx(txBytes)
+	require.True(t, res.IsOK(), fmt.Sprintf("%v", res))
 
-		// tx counter only incremented once
-		txCounter := getIntFromStore(store, anteKey)
-		require.Equal(t, int64(1), txCounter)
+	store := app.deliverState.ctx.KVStore(capKey1)
 
-		// msg counter incremented three times
-		msgCounter := getIntFromStore(store, deliverKey)
-		require.Equal(t, int64(3), msgCounter)
-	}
+	// tx counter only incremented once
+	txCounter := getIntFromStore(store, anteKey)
+	require.Equal(t, int64(1), txCounter)
+
+	// msg counter incremented three times
+	msgCounter := getIntFromStore(store, deliverKey)
+	require.Equal(t, int64(3), msgCounter)
 
 	// replace the second message with a msgCounter2
-	{
-		tx := newTxCounter(1, 3)
-		tx.Msgs = append(tx.Msgs, msgCounter2{0})
-		tx.Msgs = append(tx.Msgs, msgCounter2{1})
-		txBytes, err := codec.MarshalBinaryLengthPrefixed(tx)
-		require.NoError(t, err)
-		res := app.DeliverTx(txBytes)
-		require.True(t, res.IsOK(), fmt.Sprintf("%v", res))
 
-		store := app.deliverState.ctx.KVStore(capKey1)
+	tx = newTxCounter(1, 3)
+	tx.Msgs = append(tx.Msgs, msgCounter2{0})
+	tx.Msgs = append(tx.Msgs, msgCounter2{1})
+	txBytes, err = codec.MarshalBinaryLengthPrefixed(tx)
+	require.NoError(t, err)
+	res = app.DeliverTx(txBytes)
+	require.True(t, res.IsOK(), fmt.Sprintf("%v", res))
 
-		// tx counter only incremented once
-		txCounter := getIntFromStore(store, anteKey)
-		require.Equal(t, int64(2), txCounter)
+	store = app.deliverState.ctx.KVStore(capKey1)
 
-		// original counter increments by one
-		// new counter increments by two
-		msgCounter := getIntFromStore(store, deliverKey)
-		require.Equal(t, int64(4), msgCounter)
-		msgCounter2 := getIntFromStore(store, deliverKey2)
-		require.Equal(t, int64(2), msgCounter2)
-	}
+	// tx counter only incremented once
+	txCounter = getIntFromStore(store, anteKey)
+	require.Equal(t, int64(2), txCounter)
+
+	// original counter increments by one
+	// new counter increments by two
+	msgCounter = getIntFromStore(store, deliverKey)
+	require.Equal(t, int64(4), msgCounter)
+	msgCounter2 := getIntFromStore(store, deliverKey2)
+	require.Equal(t, int64(2), msgCounter2)
 }
 
 // Interleave calls to Check and Deliver and ensure
@@ -692,7 +702,8 @@ func TestSimulateTx(t *testing.T) {
 	nBlocks := 3
 	for blockN := 0; blockN < nBlocks; blockN++ {
 		count := int64(blockN + 1)
-		app.BeginBlock(abci.RequestBeginBlock{})
+		header := abci.Header{Height: count}
+		app.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 		tx := newTxCounter(count, count)
 		txBytes, err := cdc.MarshalBinaryLengthPrefixed(tx)
@@ -737,7 +748,9 @@ func TestRunInvalidTransaction(t *testing.T) {
 	}
 
 	app := setupBaseApp(t, anteOpt, routerOpt)
-	app.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: 1}
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 	// Transaction with no messages
 	{
@@ -847,7 +860,8 @@ func TestTxGasLimits(t *testing.T) {
 
 	app := setupBaseApp(t, anteOpt, routerOpt)
 
-	app.BeginBlock(abci.RequestBeginBlock{})
+	header := abci.Header{Height: 1}
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 	testCases := []struct {
 		tx      *txTest
@@ -932,7 +946,7 @@ func TestMaxBlockGasLimits(t *testing.T) {
 	app := setupBaseApp(t, anteOpt, routerOpt)
 	app.InitChain(abci.RequestInitChain{
 		ConsensusParams: &abci.ConsensusParams{
-			BlockSize: &abci.BlockSizeParams{
+			Block: &abci.BlockParams{
 				MaxGas: 100,
 			},
 		},
@@ -962,7 +976,8 @@ func TestMaxBlockGasLimits(t *testing.T) {
 		tx := tc.tx
 
 		// reset the block gas
-		app.BeginBlock(abci.RequestBeginBlock{})
+		header := abci.Header{Height: app.LastBlockHeight() + 1}
+		app.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 		// execute the transaction multiple times
 		for j := 0; j < tc.numDelivers; j++ {
@@ -1005,7 +1020,9 @@ func TestBaseAppAnteHandler(t *testing.T) {
 
 	app.InitChain(abci.RequestInitChain{})
 	registerTestCodec(cdc)
-	app.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: app.LastBlockHeight() + 1}
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 	// execute a tx that will fail ante handler execution
 	//
@@ -1105,14 +1122,16 @@ func TestGasConsumptionBadTx(t *testing.T) {
 	app := setupBaseApp(t, anteOpt, routerOpt)
 	app.InitChain(abci.RequestInitChain{
 		ConsensusParams: &abci.ConsensusParams{
-			BlockSize: &abci.BlockSizeParams{
+			Block: &abci.BlockParams{
 				MaxGas: 9,
 			},
 		},
 	})
 
 	app.InitChain(abci.RequestInitChain{})
-	app.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: app.LastBlockHeight() + 1}
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 	tx := newTxCounter(5, 0)
 	tx.setFailOnAnte(true)
@@ -1174,7 +1193,9 @@ func TestQuery(t *testing.T) {
 	require.Equal(t, 0, len(res.Value))
 
 	// query is still empty after a DeliverTx before we commit
-	app.BeginBlock(abci.RequestBeginBlock{})
+	header := abci.Header{Height: app.LastBlockHeight() + 1}
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	resTx = app.Deliver(tx)
 	require.True(t, resTx.IsOK(), fmt.Sprintf("%v", resTx))
 	res = app.Query(query)
@@ -1216,3 +1237,19 @@ func TestP2PQuery(t *testing.T) {
 	res = app.Query(idQuery)
 	require.Equal(t, uint32(4), res.Code)
 }
+
+func TestGetMaximumBlockGas(t *testing.T) {
+	app := setupBaseApp(t)
+
+	app.setConsensusParams(&abci.ConsensusParams{Block: &abci.BlockParams{MaxGas: 0}})
+	require.Equal(t, uint64(0), app.getMaximumBlockGas())
+
+	app.setConsensusParams(&abci.ConsensusParams{Block: &abci.BlockParams{MaxGas: -1}})
+	require.Equal(t, uint64(0), app.getMaximumBlockGas())
+
+	app.setConsensusParams(&abci.ConsensusParams{Block: &abci.BlockParams{MaxGas: 5000000}})
+	require.Equal(t, uint64(5000000), app.getMaximumBlockGas())
+
+	app.setConsensusParams(&abci.ConsensusParams{Block: &abci.BlockParams{MaxGas: -5000000}})
+	require.Panics(t, func() { app.getMaximumBlockGas() })
+}
diff --git a/client/config.go b/client/config.go
index ce57434a5..d785093a3 100644
--- a/client/config.go
+++ b/client/config.go
@@ -18,14 +18,11 @@ const (
 	flagGet = "get"
 )
 
-var configDefaults map[string]string
-
-func init() {
-	configDefaults = map[string]string{
-		"chain-id": "",
-		"output":   "text",
-		"node":     "tcp://localhost:26657",
-	}
+var configDefaults = map[string]string{
+	"chain-id":       "",
+	"output":         "text",
+	"node":           "tcp://localhost:26657",
+	"broadcast-mode": "sync",
 }
 
 // ConfigCmd returns a CLI command to interactively create a
@@ -56,13 +53,13 @@ func runConfigCmd(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("wrong number of arguments")
 	}
 
-	// Load configuration
+	// load configuration
 	tree, err := loadConfigFile(cfgFile)
 	if err != nil {
 		return err
 	}
 
-	// Print the config and exit
+	// print the config and exit
 	if len(args) == 0 {
 		s, err := tree.ToTomlString()
 		if err != nil {
@@ -73,45 +70,54 @@ func runConfigCmd(cmd *cobra.Command, args []string) error {
 	}
 
 	key := args[0]
-	// Get value action
+
+	// get config value for a given key
 	if getAction {
 		switch key {
 		case "trace", "trust-node", "indent":
 			fmt.Println(tree.GetDefault(key, false).(bool))
+
 		default:
 			if defaultValue, ok := configDefaults[key]; ok {
 				fmt.Println(tree.GetDefault(key, defaultValue).(string))
 				return nil
 			}
+
 			return errUnknownConfigKey(key)
 		}
+
 		return nil
 	}
 
-	// Set value action
 	if len(args) != 2 {
 		return fmt.Errorf("wrong number of arguments")
 	}
+
 	value := args[1]
+
+	// set config value for a given key
 	switch key {
-	case "chain-id", "output", "node":
+	case "chain-id", "output", "node", "broadcast-mode":
 		tree.Set(key, value)
+
 	case "trace", "trust-node", "indent":
 		boolVal, err := strconv.ParseBool(value)
 		if err != nil {
 			return err
 		}
+
 		tree.Set(key, boolVal)
+
 	default:
 		return errUnknownConfigKey(key)
 	}
 
-	// Save configuration to disk
+	// save configuration to disk
 	if err := saveConfigFile(cfgFile, tree); err != nil {
 		return err
 	}
-	fmt.Fprintf(os.Stderr, "configuration saved to %s\n", cfgFile)
 
+	fmt.Fprintf(os.Stderr, "configuration saved to %s\n", cfgFile)
 	return nil
 }
 
@@ -144,7 +150,7 @@ func loadConfigFile(cfgFile string) (*toml.Tree, error) {
 }
 
 func saveConfigFile(cfgFile string, tree *toml.Tree) error {
-	fp, err := os.OpenFile(cfgFile, os.O_WRONLY|os.O_CREATE, 0644)
+	fp, err := os.OpenFile(cfgFile, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644)
 	if err != nil {
 		return err
 	}
diff --git a/client/config_test.go b/client/config_test.go
new file mode 100644
index 000000000..6263a212a
--- /dev/null
+++ b/client/config_test.go
@@ -0,0 +1,44 @@
+package client
+
+import (
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/libs/cli"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// For https://github.com/cosmos/cosmos-sdk/issues/3899
+func Test_runConfigCmdTwiceWithShorterNodeValue(t *testing.T) {
+	// Prepare environment
+	t.Parallel()
+	configHome, cleanup := tmpDir(t)
+	defer cleanup()
+	_ = os.RemoveAll(filepath.Join(configHome, "config"))
+	viper.Set(cli.HomeFlag, configHome)
+
+	// Init command config
+	cmd := ConfigCmd(configHome)
+	assert.NotNil(t, cmd)
+
+	err := cmd.RunE(cmd, []string{"node", "tcp://localhost:26657"})
+	assert.Nil(t, err)
+
+	err = cmd.RunE(cmd, []string{"node", "--get"})
+	assert.Nil(t, err)
+
+	err = cmd.RunE(cmd, []string{"node", "tcp://local:26657"})
+	assert.Nil(t, err)
+
+	err = cmd.RunE(cmd, []string{"node", "--get"})
+	assert.Nil(t, err)
+}
+
+func tmpDir(t *testing.T) (string, func()) {
+	dir, err := ioutil.TempDir("", t.Name()+"_")
+	require.NoError(t, err)
+	return dir, func() { _ = os.RemoveAll(dir) }
+}
diff --git a/client/context/broadcast.go b/client/context/broadcast.go
index 0503c8e59..4a754a529 100644
--- a/client/context/broadcast.go
+++ b/client/context/broadcast.go
@@ -3,6 +3,7 @@ package context
 import (
 	"fmt"
 
+	"github.com/cosmos/cosmos-sdk/client"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
@@ -11,29 +12,36 @@ import (
 // an intermediate structure which is logged if the context has a logger
 // defined.
 func (ctx CLIContext) BroadcastTx(txBytes []byte) (res sdk.TxResponse, err error) {
-	if ctx.Async {
-		if res, err = ctx.BroadcastTxAsync(txBytes); err != nil {
-			return
-		}
-		return
+	switch ctx.BroadcastMode {
+	case client.BroadcastSync:
+		res, err = ctx.BroadcastTxSync(txBytes)
+
+	case client.BroadcastAsync:
+		res, err = ctx.BroadcastTxAsync(txBytes)
+
+	case client.BroadcastBlock:
+		res, err = ctx.BroadcastTxCommit(txBytes)
+
+	default:
+		return sdk.TxResponse{}, fmt.Errorf("unsupported return type %s; supported types: sync, async, block", ctx.BroadcastMode)
 	}
 
-	if res, err = ctx.BroadcastTxAndAwaitCommit(txBytes); err != nil {
-		return
-	}
-
-	return
+	return res, err
 }
 
-// BroadcastTxAndAwaitCommit broadcasts transaction bytes to a Tendermint node
-// and waits for a commit.
-func (ctx CLIContext) BroadcastTxAndAwaitCommit(tx []byte) (sdk.TxResponse, error) {
+// BroadcastTxCommit broadcasts transaction bytes to a Tendermint node and
+// waits for a commit.
+//
+// NOTE: This should ideally not be used as the request may timeout but the tx
+// may still be included in a block. Use BroadcastTxAsync or BroadcastTxSync
+// instead.
+func (ctx CLIContext) BroadcastTxCommit(txBytes []byte) (sdk.TxResponse, error) {
 	node, err := ctx.GetNode()
 	if err != nil {
 		return sdk.TxResponse{}, err
 	}
 
-	res, err := node.BroadcastTxCommit(tx)
+	res, err := node.BroadcastTxCommit(txBytes)
 	if err != nil {
 		return sdk.NewResponseFormatBroadcastTxCommit(res), err
 	}
@@ -46,35 +54,29 @@ func (ctx CLIContext) BroadcastTxAndAwaitCommit(tx []byte) (sdk.TxResponse, erro
 		return sdk.NewResponseFormatBroadcastTxCommit(res), fmt.Errorf(res.DeliverTx.Log)
 	}
 
-	return sdk.NewResponseFormatBroadcastTxCommit(res), err
+	return sdk.NewResponseFormatBroadcastTxCommit(res), nil
 }
 
-// BroadcastTxSync broadcasts transaction bytes to a Tendermint node synchronously.
-func (ctx CLIContext) BroadcastTxSync(tx []byte) (sdk.TxResponse, error) {
+// BroadcastTxSync broadcasts transaction bytes to a Tendermint node
+// synchronously (i.e. returns after CheckTx execution).
+func (ctx CLIContext) BroadcastTxSync(txBytes []byte) (sdk.TxResponse, error) {
 	node, err := ctx.GetNode()
 	if err != nil {
 		return sdk.TxResponse{}, err
 	}
 
-	res, err := node.BroadcastTxSync(tx)
-	if err != nil {
-		return sdk.NewResponseFormatBroadcastTx(res), err
-	}
-
+	res, err := node.BroadcastTxSync(txBytes)
 	return sdk.NewResponseFormatBroadcastTx(res), err
 }
 
-// BroadcastTxAsync broadcasts transaction bytes to a Tendermint node asynchronously.
-func (ctx CLIContext) BroadcastTxAsync(tx []byte) (sdk.TxResponse, error) {
+// BroadcastTxAsync broadcasts transaction bytes to a Tendermint node
+// asynchronously (i.e. returns immediately).
+func (ctx CLIContext) BroadcastTxAsync(txBytes []byte) (sdk.TxResponse, error) {
 	node, err := ctx.GetNode()
 	if err != nil {
 		return sdk.TxResponse{}, err
 	}
 
-	res, err := node.BroadcastTxAsync(tx)
-	if err != nil {
-		return sdk.NewResponseFormatBroadcastTx(res), err
-	}
-
+	res, err := node.BroadcastTxAsync(txBytes)
 	return sdk.NewResponseFormatBroadcastTx(res), err
 }
diff --git a/client/context/context.go b/client/context/context.go
index beffad0c4..e9d7e6782 100644
--- a/client/context/context.go
+++ b/client/context/context.go
@@ -44,7 +44,7 @@ type CLIContext struct {
 	AccountStore  string
 	TrustNode     bool
 	UseLedger     bool
-	Async         bool
+	BroadcastMode string
 	PrintResponse bool
 	Verifier      tmlite.Verifier
 	VerifierHome  string
@@ -67,7 +67,8 @@ func NewCLIContext() CLIContext {
 	}
 
 	from := viper.GetString(client.FlagFrom)
-	fromAddress, fromName, err := GetFromFields(from)
+	genOnly := viper.GetBool(client.FlagGenerateOnly)
+	fromAddress, fromName, err := GetFromFields(from, genOnly)
 	if err != nil {
 		fmt.Printf("failed to get from fields: %v", err)
 		os.Exit(1)
@@ -89,11 +90,11 @@ func NewCLIContext() CLIContext {
 		Height:        viper.GetInt64(client.FlagHeight),
 		TrustNode:     viper.GetBool(client.FlagTrustNode),
 		UseLedger:     viper.GetBool(client.FlagUseLedger),
-		Async:         viper.GetBool(client.FlagAsync),
+		BroadcastMode: viper.GetString(client.FlagBroadcastMode),
 		PrintResponse: viper.GetBool(client.FlagPrintResponse),
 		Verifier:      verifier,
 		Simulate:      viper.GetBool(client.FlagDryRun),
-		GenerateOnly:  viper.GetBool(client.FlagGenerateOnly),
+		GenerateOnly:  genOnly,
 		FromAddress:   fromAddress,
 		FromName:      fromName,
 		Indent:        viper.GetBool(client.FlagIndentResponse),
@@ -247,6 +248,13 @@ func (ctx CLIContext) WithFromAddress(addr sdk.AccAddress) CLIContext {
 	return ctx
 }
 
+// WithBroadcastMode returns a copy of the context with an updated broadcast
+// mode.
+func (ctx CLIContext) WithBroadcastMode(mode string) CLIContext {
+	ctx.BroadcastMode = mode
+	return ctx
+}
+
 // PrintOutput prints output while respecting output and indent flags
 // NOTE: pass in marshalled structs that have been unmarshaled
 // because this function will panic on marshaling errors
@@ -259,7 +267,7 @@ func (ctx CLIContext) PrintOutput(toPrint fmt.Stringer) (err error) {
 
 	case "json":
 		if ctx.Indent {
-			out, err = ctx.Codec.MarshalJSONIndent(toPrint, "", " ")
+			out, err = ctx.Codec.MarshalJSONIndent(toPrint, "", "  ")
 		} else {
 			out, err = ctx.Codec.MarshalJSON(toPrint)
 		}
@@ -274,12 +282,22 @@ func (ctx CLIContext) PrintOutput(toPrint fmt.Stringer) (err error) {
 }
 
 // GetFromFields returns a from account address and Keybase name given either
-// an address or key name.
-func GetFromFields(from string) (sdk.AccAddress, string, error) {
+// an address or key name. If genOnly is true, only a valid Bech32 cosmos
+// address is returned.
+func GetFromFields(from string, genOnly bool) (sdk.AccAddress, string, error) {
 	if from == "" {
 		return nil, "", nil
 	}
 
+	if genOnly {
+		addr, err := sdk.AccAddressFromBech32(from)
+		if err != nil {
+			return nil, "", err
+		}
+
+		return addr, "", nil
+	}
+
 	keybase, err := keys.NewKeyBaseFromHomeFlag()
 	if err != nil {
 		return nil, "", err
diff --git a/client/flags.go b/client/flags.go
index 62d912908..77aec7e24 100644
--- a/client/flags.go
+++ b/client/flags.go
@@ -18,11 +18,20 @@ const (
 	DefaultGasLimit      = 200000
 	GasFlagAuto          = "auto"
 
+	// BroadcastBlock defines a tx broadcasting mode where the client waits for
+	// the tx to be committed in a block.
+	BroadcastBlock = "block"
+	// BroadcastSync defines a tx broadcasting mode where the client waits for
+	// a CheckTx execution response only.
+	BroadcastSync = "sync"
+	// BroadcastAsync defines a tx broadcasting mode where the client returns
+	// immediately.
+	BroadcastAsync = "async"
+
 	FlagUseLedger          = "ledger"
 	FlagChainID            = "chain-id"
 	FlagNode               = "node"
 	FlagHeight             = "height"
-	FlagGas                = "gas"
 	FlagGasAdjustment      = "gas-adjustment"
 	FlagTrustNode          = "trust-node"
 	FlagFrom               = "from"
@@ -32,7 +41,7 @@ const (
 	FlagMemo               = "memo"
 	FlagFees               = "fees"
 	FlagGasPrices          = "gas-prices"
-	FlagAsync              = "async"
+	FlagBroadcastMode      = "broadcast-mode"
 	FlagPrintResponse      = "print-response"
 	FlagDryRun             = "dry-run"
 	FlagGenerateOnly       = "generate-only"
@@ -40,10 +49,6 @@ const (
 	FlagListenAddr         = "laddr"
 	FlagCORS               = "cors"
 	FlagMaxOpenConnections = "max-open"
-	FlagTLS                = "tls"
-	FlagSSLHosts           = "ssl-hosts"
-	FlagSSLCertFile        = "ssl-certfile"
-	FlagSSLKeyFile         = "ssl-keyfile"
 	FlagOutputDocument     = "output-document" // inspired by wget -O
 	FlagSkipConfirmation   = "yes"
 )
@@ -62,7 +67,6 @@ func GetCommands(cmds ...*cobra.Command) []*cobra.Command {
 		c.Flags().Bool(FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
 		c.Flags().Bool(FlagUseLedger, false, "Use a connected Ledger device")
 		c.Flags().String(FlagNode, "tcp://localhost:26657", "<host>:<port> to tendermint rpc interface for this chain")
-		c.Flags().Int64(FlagHeight, 0, "block height to query, omit to get most recent provable block")
 		viper.BindPFlag(FlagTrustNode, c.Flags().Lookup(FlagTrustNode))
 		viper.BindPFlag(FlagUseLedger, c.Flags().Lookup(FlagUseLedger))
 		viper.BindPFlag(FlagNode, c.Flags().Lookup(FlagNode))
@@ -77,15 +81,15 @@ func PostCommands(cmds ...*cobra.Command) []*cobra.Command {
 	for _, c := range cmds {
 		c.Flags().Bool(FlagIndentResponse, false, "Add indent to JSON response")
 		c.Flags().String(FlagFrom, "", "Name or address of private key with which to sign")
-		c.Flags().Uint64(FlagAccountNumber, 0, "AccountNumber number to sign the tx")
-		c.Flags().Uint64(FlagSequence, 0, "Sequence number to sign the tx")
+		c.Flags().Uint64P(FlagAccountNumber, "a", 0, "The account number of the signing account (offline mode only)")
+		c.Flags().Uint64P(FlagSequence, "s", 0, "The sequence number of the signing account (offline mode only)")
 		c.Flags().String(FlagMemo, "", "Memo to send along with transaction")
-		c.Flags().String(FlagFees, "", "Fees to pay along with transaction; eg: 10stake,1atom")
-		c.Flags().String(FlagGasPrices, "", "Gas prices to determine the transaction fee (e.g. 0.00001stake)")
+		c.Flags().String(FlagFees, "", "Fees to pay along with transaction; eg: 10uatom")
+		c.Flags().String(FlagGasPrices, "", "Gas prices to determine the transaction fee (e.g. 10uatom)")
 		c.Flags().String(FlagNode, "tcp://localhost:26657", "<host>:<port> to tendermint rpc interface for this chain")
 		c.Flags().Bool(FlagUseLedger, false, "Use a connected Ledger device")
 		c.Flags().Float64(FlagGasAdjustment, DefaultGasAdjustment, "adjustment factor to be multiplied against the estimate returned by the tx simulation; if the gas limit is set manually this flag is ignored ")
-		c.Flags().Bool(FlagAsync, false, "broadcast transactions asynchronously")
+		c.Flags().StringP(FlagBroadcastMode, "b", BroadcastSync, "Transaction broadcasting mode (sync|async|block)")
 		c.Flags().Bool(FlagPrintResponse, true, "return tx response (only works with async = false)")
 		c.Flags().Bool(FlagTrustNode, true, "Trust connected full node (don't verify proofs for responses)")
 		c.Flags().Bool(FlagDryRun, false, "ignore the --gas flag and perform a simulation of a transaction, but don't broadcast it")
@@ -111,10 +115,6 @@ func PostCommands(cmds ...*cobra.Command) []*cobra.Command {
 func RegisterRestServerFlags(cmd *cobra.Command) *cobra.Command {
 	cmd = GetCommands(cmd)[0]
 	cmd.Flags().String(FlagListenAddr, "tcp://localhost:1317", "The address for the server to listen on")
-	cmd.Flags().Bool(FlagTLS, false, "Enable SSL/TLS layer")
-	cmd.Flags().String(FlagSSLHosts, "", "Comma-separated hostnames and IPs to generate a certificate for")
-	cmd.Flags().String(FlagSSLCertFile, "", "Path to a SSL certificate file. If not supplied, a self-signed certificate will be generated.")
-	cmd.Flags().String(FlagSSLKeyFile, "", "Path to a key file; ignored if a certificate file is not supplied.")
 	cmd.Flags().String(FlagCORS, "", "Set the domains that can make CORS requests (* for all)")
 	cmd.Flags().Int(FlagMaxOpenConnections, 1000, "The number of maximum open connections")
 
diff --git a/client/keys/add.go b/client/keys/add.go
index c11316d1d..7ab5ecdb8 100644
--- a/client/keys/add.go
+++ b/client/keys/add.go
@@ -74,6 +74,7 @@ the flag --nosort is set.
 	cmd.Flags().Bool(flagDryRun, false, "Perform action, but don't add key to local keystore")
 	cmd.Flags().Uint32(flagAccount, 0, "Account number for HD derivation")
 	cmd.Flags().Uint32(flagIndex, 0, "Address index number for HD derivation")
+	cmd.Flags().Bool(client.FlagIndentResponse, false, "Add indent to JSON response")
 	return cmd
 }
 
@@ -146,7 +147,7 @@ func runAddCmd(_ *cobra.Command, args []string) error {
 				return err
 			}
 
-			fmt.Fprintf(os.Stderr, "Key %q saved to disk.", name)
+			fmt.Fprintf(os.Stderr, "Key %q saved to disk.\n", name)
 			return nil
 		}
 
@@ -216,7 +217,7 @@ func runAddCmd(_ *cobra.Command, args []string) error {
 	}
 
 	if !bip39.IsMnemonicValid(mnemonic) {
-		fmt.Fprintf(os.Stderr, "Error: Mnemonic is not valid")
+		fmt.Fprintf(os.Stderr, "Error: Mnemonic is not valid.\n")
 		return nil
 	}
 
diff --git a/client/keys/list.go b/client/keys/list.go
index db4cf0fe2..19873aabb 100644
--- a/client/keys/list.go
+++ b/client/keys/list.go
@@ -1,17 +1,20 @@
 package keys
 
 import (
+	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/spf13/cobra"
 )
 
 func listKeysCmd() *cobra.Command {
-	return &cobra.Command{
+	cmd := &cobra.Command{
 		Use:   "list",
 		Short: "List all keys",
 		Long: `Return a list of all public keys stored by this key manager
 along with their associated name and address.`,
 		RunE: runListCmd,
 	}
+	cmd.Flags().Bool(client.FlagIndentResponse, false, "Add indent to JSON response")
+	return cmd
 }
 
 func runListCmd(cmd *cobra.Command, args []string) error {
diff --git a/client/keys/show.go b/client/keys/show.go
index e1d253cd3..eaa800e11 100644
--- a/client/keys/show.go
+++ b/client/keys/show.go
@@ -3,6 +3,7 @@ package keys
 import (
 	"errors"
 	"fmt"
+	"github.com/cosmos/cosmos-sdk/client"
 
 	"github.com/cosmos/cosmos-sdk/crypto"
 	"github.com/cosmos/cosmos-sdk/crypto/keys"
@@ -49,6 +50,7 @@ consisting of all the keys provided by name and multisig threshold.`,
 	cmd.Flags().BoolP(FlagDevice, "d", false, "Output the address in the device")
 	cmd.Flags().Uint(flagMultiSigThreshold, 1, "K out of N required signatures")
 	cmd.Flags().BoolP(flagShowMultiSig, "m", false, "Output multisig pubkey constituents, threshold, and weights")
+	cmd.Flags().Bool(client.FlagIndentResponse, false, "Add indent to JSON response")
 
 	return cmd
 }
diff --git a/client/keys/types.go b/client/keys/types.go
index 75ecabe83..079ef4962 100644
--- a/client/keys/types.go
+++ b/client/keys/types.go
@@ -11,6 +11,17 @@ type AddNewKey struct {
 	Index    int    `json:"index,string,omitempty"`
 }
 
+// NewAddNewKey constructs a new AddNewKey request structure.
+func NewAddNewKey(name, password, mnemonic string, account, index int) AddNewKey {
+	return AddNewKey{
+		Name:     name,
+		Password: password,
+		Mnemonic: mnemonic,
+		Account:  account,
+		Index:    index,
+	}
+}
+
 // RecoverKeyBody recovers a key
 type RecoverKey struct {
 	Password string `json:"password"`
@@ -19,13 +30,26 @@ type RecoverKey struct {
 	Index    int    `json:"index,string,omitempty"`
 }
 
+// NewRecoverKey constructs a new RecoverKey request structure.
+func NewRecoverKey(password, mnemonic string, account, index int) RecoverKey {
+	return RecoverKey{Password: password, Mnemonic: mnemonic, Account: account, Index: index}
+}
+
 // UpdateKeyReq requests updating a key
 type UpdateKeyReq struct {
 	OldPassword string `json:"old_password"`
 	NewPassword string `json:"new_password"`
 }
 
+// NewUpdateKeyReq constructs a new UpdateKeyReq structure.
+func NewUpdateKeyReq(old, new string) UpdateKeyReq {
+	return UpdateKeyReq{OldPassword: old, NewPassword: new}
+}
+
 // DeleteKeyReq requests deleting a key
 type DeleteKeyReq struct {
 	Password string `json:"password"`
 }
+
+// NewDeleteKeyReq constructs a new DeleteKeyReq structure.
+func NewDeleteKeyReq(password string) DeleteKeyReq { return DeleteKeyReq{Password: password} }
diff --git a/client/keys/utils.go b/client/keys/utils.go
index 5391e704f..c86161038 100644
--- a/client/keys/utils.go
+++ b/client/keys/utils.go
@@ -118,8 +118,14 @@ func printKeyInfo(keyInfo keys.Info, bechKeyOut bechKeyOutFn) {
 		printKeyTextHeader()
 		printKeyOutput(ko)
 
-	case "json":
-		out, err := MarshalJSON(ko)
+	case OutputFormatJSON:
+		var out []byte
+		var err error
+		if viper.GetBool(client.FlagIndentResponse) {
+			out, err = cdc.MarshalJSONIndent(ko, "", "  ")
+		} else {
+			out, err = cdc.MarshalJSON(ko)
+		}
 		if err != nil {
 			panic(err)
 		}
@@ -142,11 +148,18 @@ func printInfos(infos []keys.Info) {
 		}
 
 	case OutputFormatJSON:
-		out, err := MarshalJSON(kos)
+		var out []byte
+		var err error
+
+		if viper.GetBool(client.FlagIndentResponse) {
+			out, err = cdc.MarshalJSONIndent(kos, "", "  ")
+		} else {
+			out, err = cdc.MarshalJSON(kos)
+		}
+
 		if err != nil {
 			panic(err)
 		}
-
 		fmt.Println(string(out))
 	}
 }
diff --git a/client/lcd/certificates.go b/client/lcd/certificates.go
deleted file mode 100644
index 0ec527e13..000000000
--- a/client/lcd/certificates.go
+++ /dev/null
@@ -1,175 +0,0 @@
-package lcd
-
-import (
-	"bytes"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/sha256"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"math/big"
-	"net"
-	"os"
-	"strings"
-	"time"
-)
-
-// default: 30 days
-const defaultValidFor = 30 * 24 * time.Hour
-
-func generateSelfSignedCert(host string) (certBytes []byte, priv *ecdsa.PrivateKey, err error) {
-	priv, err = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	notBefore := time.Now()
-	notAfter := notBefore.Add(defaultValidFor)
-	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
-	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
-	if err != nil {
-		err = fmt.Errorf("failed to generate serial number: %s", err)
-		return
-	}
-
-	template := x509.Certificate{
-		SerialNumber: serialNumber,
-		Subject: pkix.Name{
-			Organization: []string{"Gaia Lite"},
-		},
-		DNSNames:              []string{"localhost"},
-		NotBefore:             notBefore,
-		NotAfter:              notAfter,
-		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-		IsCA:                  true,
-	}
-	hosts := strings.Split(host, ",")
-	for _, h := range hosts {
-		if ip := net.ParseIP(h); ip != nil {
-			template.IPAddresses = append(template.IPAddresses, ip)
-		} else {
-			template.DNSNames = append(template.DNSNames, h)
-		}
-	}
-
-	certBytes, err = x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
-	if err != nil {
-		err = fmt.Errorf("couldn't create certificate: %s", err)
-		return
-	}
-	return
-}
-
-func writeCertAndPrivKey(certBytes []byte, priv *ecdsa.PrivateKey) (certFile string, keyFile string, err error) {
-	if priv == nil {
-		err = errors.New("private key is nil")
-		return
-	}
-	certFile, err = writeCertificateFile(certBytes)
-	if err != nil {
-		return
-	}
-	keyFile, err = writeKeyFile(priv)
-	return
-}
-
-func writeCertificateFile(certBytes []byte) (filename string, err error) {
-	f, err := ioutil.TempFile("", "cert_")
-	if err != nil {
-		return
-	}
-	defer f.Close()
-	filename = f.Name()
-	if err := pem.Encode(f, &pem.Block{Type: "CERTIFICATE", Bytes: certBytes}); err != nil {
-		return filename, fmt.Errorf("failed to write data to %s: %s", filename, err)
-	}
-	return
-}
-
-func writeKeyFile(priv *ecdsa.PrivateKey) (filename string, err error) {
-	f, err := ioutil.TempFile("", "key_")
-	if err != nil {
-		return
-	}
-	defer f.Close()
-	filename = f.Name()
-	block, err := pemBlockForKey(priv)
-	if err != nil {
-		return
-	}
-	if err := pem.Encode(f, block); err != nil {
-		return filename, fmt.Errorf("failed to write data to %s: %s", filename, err)
-	}
-	return
-}
-
-func pemBlockForKey(priv *ecdsa.PrivateKey) (*pem.Block, error) {
-	b, err := x509.MarshalECPrivateKey(priv)
-	if err != nil {
-		return nil, fmt.Errorf("unable to marshal ECDSA private key: %v", err)
-	}
-	return &pem.Block{Type: "EC PRIVATE KEY", Bytes: b}, nil
-
-}
-
-func genCertKeyFilesAndReturnFingerprint(sslHosts string) (certFile, keyFile string, fingerprint string, err error) {
-	certBytes, priv, err := generateSelfSignedCert(sslHosts)
-	if err != nil {
-		return
-	}
-	certFile, keyFile, err = writeCertAndPrivKey(certBytes, priv)
-	cleanupFunc := func() {
-		os.Remove(certFile)
-		os.Remove(keyFile)
-	}
-	// Either of the files could have been written already,
-	// thus clean up regardless of the error.
-	if err != nil {
-		defer cleanupFunc()
-		return
-	}
-	fingerprint, err = fingerprintForCertificate(certBytes)
-	if err != nil {
-		defer cleanupFunc()
-		return
-	}
-	return
-}
-
-func fingerprintForCertificate(certBytes []byte) (string, error) {
-	cert, err := x509.ParseCertificate(certBytes)
-	if err != nil {
-		return "", err
-	}
-	h := sha256.New()
-	h.Write(cert.Raw)
-	fingerprintBytes := h.Sum(nil)
-	var buf bytes.Buffer
-	for i, b := range fingerprintBytes {
-		if i > 0 {
-			fmt.Fprintf(&buf, ":")
-		}
-		fmt.Fprintf(&buf, "%02X", b)
-	}
-	return fmt.Sprintf("SHA256 Fingerprint=%s", buf.String()), nil
-}
-
-func fingerprintFromFile(certFile string) (string, error) {
-	f, err := os.Open(certFile)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-	data, err := ioutil.ReadAll(f)
-	if err != nil {
-		return "", err
-	}
-	block, _ := pem.Decode(data)
-	if block == nil {
-		return "", fmt.Errorf("couldn't find PEM data in %s", certFile)
-	}
-	return fingerprintForCertificate(block.Bytes)
-}
diff --git a/client/lcd/certificates_test.go b/client/lcd/certificates_test.go
deleted file mode 100644
index 3f48c194c..000000000
--- a/client/lcd/certificates_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package lcd
-
-import (
-	"crypto/ecdsa"
-	"crypto/x509"
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestGenerateSelfSignedCert(t *testing.T) {
-	host := "127.0.0.1,localhost,::1"
-	certBytes, _, err := generateSelfSignedCert(host)
-	require.Nil(t, err)
-	cert, err := x509.ParseCertificate(certBytes)
-	require.Nil(t, err)
-	require.Equal(t, 2, len(cert.IPAddresses))
-	require.Equal(t, 2, len(cert.DNSNames))
-	require.True(t, cert.IsCA)
-}
-
-func TestWriteCertAndPrivKey(t *testing.T) {
-	expectedPerm := "-rw-------"
-	derBytes, priv, err := generateSelfSignedCert("localhost")
-	require.Nil(t, err)
-	type args struct {
-		certBytes []byte
-		priv      *ecdsa.PrivateKey
-	}
-	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-	}{
-		{"valid certificate", args{derBytes, priv}, false},
-		{"garbage", args{[]byte("some garbage"), nil}, true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotCertFile, gotKeyFile, err := writeCertAndPrivKey(tt.args.certBytes, tt.args.priv)
-			defer os.Remove(gotCertFile)
-			defer os.Remove(gotKeyFile)
-			if tt.wantErr {
-				require.NotNil(t, err)
-				return
-			}
-			require.Nil(t, err)
-			info, err := os.Stat(gotCertFile)
-			require.Nil(t, err)
-			require.True(t, info.Mode().IsRegular())
-			require.Equal(t, expectedPerm, info.Mode().String())
-			info, err = os.Stat(gotKeyFile)
-			require.Nil(t, err)
-			require.True(t, info.Mode().IsRegular())
-			require.Equal(t, expectedPerm, info.Mode().String())
-		})
-	}
-}
-
-func TestFingerprintFromFile(t *testing.T) {
-	cert := `-----BEGIN CERTIFICATE-----
-MIIBbDCCARGgAwIBAgIQSuFKYv/22v+cxtVgMUrQADAKBggqhkjOPQQDAjASMRAw
-DgYDVQQKEwdBY21lIENvMB4XDTE4MDkyMDIzNDQyNloXDTE5MDkyMDIzNDQyNlow
-EjEQMA4GA1UEChMHQWNtZSBDbzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABDIo
-ujAesRczcPVAWiLhpeV1B7hS/RI2LJaGj3QjyJ8hiUthJTPIamr8m7LuS/U5fS0o
-hY297YeTIGo9YkxClICjSTBHMA4GA1UdDwEB/wQEAwICpDATBgNVHSUEDDAKBggr
-BgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MA8GA1UdEQQIMAaHBH8AAAEwCgYIKoZI
-zj0EAwIDSQAwRgIhAKnwbhX9FrGG1otCVLwhClQ3RaLxnNpCgIGTqSimb34cAiEA
-stMN+IqMCKWlZyGqxGIiyksMLMEU3lRqKNQn2EoAZJY=
------END CERTIFICATE-----`
-	wantFingerprint := `SHA256 Fingerprint=0B:ED:9A:AA:A2:D1:7E:B2:53:56:F6:FC:C0:E6:1A:69:70:21:A2:B0:90:FC:AF:BB:EF:AE:2C:78:52:AB:68:40`
-	certFile, err := ioutil.TempFile("", "test_cert_")
-	require.Nil(t, err)
-	_, err = certFile.Write([]byte(cert))
-	require.Nil(t, err)
-	err = certFile.Close()
-	require.Nil(t, err)
-	defer os.Remove(certFile.Name())
-	fingerprint, err := fingerprintFromFile(certFile.Name())
-	require.Nil(t, err)
-	require.Equal(t, wantFingerprint, fingerprint)
-
-	// test failure
-	emptyFile, err := ioutil.TempFile("", "test_cert_")
-	require.Nil(t, err)
-	err = emptyFile.Close()
-	require.Nil(t, err)
-	defer os.Remove(emptyFile.Name())
-	_, err = fingerprintFromFile(emptyFile.Name())
-	require.NotNil(t, err)
-}
diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go
index 88845a731..55c773cfa 100644
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@@ -11,6 +11,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/cosmos/cosmos-sdk/x/mint"
+
 	"github.com/stretchr/testify/require"
 
 	"github.com/cosmos/cosmos-sdk/client"
@@ -520,9 +522,18 @@ func TestBonding(t *testing.T) {
 	// test redelegation
 	rdTokens := sdk.TokensFromTendermintPower(30)
 	resultTx = doBeginRedelegation(t, port, name1, pw, addr, operAddrs[0], operAddrs[1], rdTokens, fees)
+	require.Equal(t, uint32(0), resultTx.Code)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
-	require.Equal(t, uint32(0), resultTx.Code)
+	// query delegations, unbondings and redelegations from validator and delegator
+	delegatorDels = getDelegatorDelegations(t, port, addr)
+	require.Len(t, delegatorDels, 1)
+	require.Equal(t, operAddrs[1], delegatorDels[0].ValidatorAddress)
+
+	// TODO uncomment once all validators actually sign in the lcd tests
+	//validator2 := getValidator(t, port, operAddrs[1])
+	//delTokensAfterRedelegation := validator2.ShareTokens(delegatorDels[0].GetShares())
+	//require.Equal(t, rdTokens.ToDec(), delTokensAfterRedelegation)
 
 	// verify balance after paying fees
 	acc = getAccount(t, port, addr)
@@ -542,20 +553,6 @@ func TestBonding(t *testing.T) {
 	require.Len(t, txs, 1)
 	require.Equal(t, resultTx.Height, txs[0].Height)
 
-	// query delegations, unbondings and redelegations from validator and delegator
-	delegatorDels = getDelegatorDelegations(t, port, addr)
-	require.Len(t, delegatorDels, 1)
-	require.Equal(t, operAddrs[1], delegatorDels[0].ValidatorAddress)
-
-	// because the second validator never signs during these tests, if this
-	// this test takes a long time to run,  eventually this second validator
-	// will get slashed, meaning that it's exchange rate is no-longer 1-to-1,
-	// hence we utilize the exchange rate in the following test
-
-	validator2 := getValidator(t, port, operAddrs[1])
-	delTokensAfterRedelegation := validator2.ShareTokens(delegatorDels[0].GetShares())
-	require.Equal(t, rdTokens.ToDec(), delTokensAfterRedelegation)
-
 	redelegation := getRedelegations(t, port, addr, operAddrs[0], operAddrs[1])
 	require.Len(t, redelegation, 1)
 	require.Len(t, redelegation[0].Entries, 1)
@@ -614,7 +611,9 @@ func TestSubmitProposal(t *testing.T) {
 	require.Equal(t, uint32(0), resultTx.Code)
 
 	var proposalID uint64
-	cdc.MustUnmarshalBinaryLengthPrefixed(resultTx.Data, &proposalID)
+	bz, err := hex.DecodeString(resultTx.Data)
+	require.NoError(t, err)
+	cdc.MustUnmarshalBinaryLengthPrefixed(bz, &proposalID)
 
 	// verify balance
 	acc = getAccount(t, port, addr)
@@ -649,7 +648,9 @@ func TestDeposit(t *testing.T) {
 	require.Equal(t, uint32(0), resultTx.Code)
 
 	var proposalID uint64
-	cdc.MustUnmarshalBinaryLengthPrefixed(resultTx.Data, &proposalID)
+	bz, err := hex.DecodeString(resultTx.Data)
+	require.NoError(t, err)
+	cdc.MustUnmarshalBinaryLengthPrefixed(bz, &proposalID)
 
 	// verify balance
 	acc = getAccount(t, port, addr)
@@ -680,7 +681,7 @@ func TestDeposit(t *testing.T) {
 	// query proposal
 	totalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(10))}
 	proposal = getProposal(t, port, proposalID)
-	require.True(t, proposal.GetTotalDeposit().IsEqual(totalCoins))
+	require.True(t, proposal.TotalDeposit.IsEqual(totalCoins))
 
 	// query deposit
 	deposit := getDeposit(t, port, proposalID, addr)
@@ -706,7 +707,9 @@ func TestVote(t *testing.T) {
 	require.Equal(t, uint32(0), resultTx.Code)
 
 	var proposalID uint64
-	cdc.MustUnmarshalBinaryLengthPrefixed(resultTx.Data, &proposalID)
+	bz, err := hex.DecodeString(resultTx.Data)
+	require.NoError(t, err)
+	cdc.MustUnmarshalBinaryLengthPrefixed(bz, &proposalID)
 
 	// verify balance
 	acc = getAccount(t, port, addr)
@@ -718,7 +721,7 @@ func TestVote(t *testing.T) {
 	// query proposal
 	proposal := getProposal(t, port, proposalID)
 	require.Equal(t, "Test", proposal.GetTitle())
-	require.Equal(t, gov.StatusVotingPeriod, proposal.GetStatus())
+	require.Equal(t, gov.StatusVotingPeriod, proposal.Status)
 
 	// vote
 	resultTx = doVote(t, port, seed, name1, pw, addr, proposalID, "Yes", fees)
@@ -787,6 +790,8 @@ func TestUnjail(t *testing.T) {
 	require.Equal(t, true, signingInfo.IndexOffset > 0)
 	require.Equal(t, time.Unix(0, 0).UTC(), signingInfo.JailedUntil)
 	require.Equal(t, true, signingInfo.MissedBlocksCounter == 0)
+	signingInfoList := getSigningInfoList(t, port)
+	require.NotZero(t, len(signingInfoList))
 }
 
 func TestProposalsQuery(t *testing.T) {
@@ -805,18 +810,24 @@ func TestProposalsQuery(t *testing.T) {
 	// Addr1 proposes (and deposits) proposals #1 and #2
 	resultTx := doSubmitProposal(t, port, seeds[0], names[0], passwords[0], addrs[0], halfMinDeposit, fees)
 	var proposalID1 uint64
-	cdc.MustUnmarshalBinaryLengthPrefixed(resultTx.Data, &proposalID1)
+	bz, err := hex.DecodeString(resultTx.Data)
+	require.NoError(t, err)
+	cdc.MustUnmarshalBinaryLengthPrefixed(bz, &proposalID1)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	resultTx = doSubmitProposal(t, port, seeds[0], names[0], passwords[0], addrs[0], halfMinDeposit, fees)
 	var proposalID2 uint64
-	cdc.MustUnmarshalBinaryLengthPrefixed(resultTx.Data, &proposalID2)
+	bz, err = hex.DecodeString(resultTx.Data)
+	require.NoError(t, err)
+	cdc.MustUnmarshalBinaryLengthPrefixed(bz, &proposalID2)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	// Addr2 proposes (and deposits) proposals #3
 	resultTx = doSubmitProposal(t, port, seeds[1], names[1], passwords[1], addrs[1], halfMinDeposit, fees)
 	var proposalID3 uint64
-	cdc.MustUnmarshalBinaryLengthPrefixed(resultTx.Data, &proposalID3)
+	bz, err = hex.DecodeString(resultTx.Data)
+	require.NoError(t, err)
+	cdc.MustUnmarshalBinaryLengthPrefixed(bz, &proposalID3)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	// Addr2 deposits on proposals #2 & #3
@@ -855,13 +866,13 @@ func TestProposalsQuery(t *testing.T) {
 	// Only proposals #1 should be in Deposit Period
 	proposals := getProposalsFilterStatus(t, port, gov.StatusDepositPeriod)
 	require.Len(t, proposals, 1)
-	require.Equal(t, proposalID1, proposals[0].GetProposalID())
+	require.Equal(t, proposalID1, proposals[0].ProposalID)
 
 	// Only proposals #2 and #3 should be in Voting Period
 	proposals = getProposalsFilterStatus(t, port, gov.StatusVotingPeriod)
 	require.Len(t, proposals, 2)
-	require.Equal(t, proposalID2, proposals[0].GetProposalID())
-	require.Equal(t, proposalID3, proposals[1].GetProposalID())
+	require.Equal(t, proposalID2, proposals[0].ProposalID)
+	require.Equal(t, proposalID3, proposals[1].ProposalID)
 
 	// Addr1 votes on proposals #2 & #3
 	resultTx = doVote(t, port, seeds[0], names[0], passwords[0], addrs[0], proposalID2, "Yes", fees)
@@ -875,31 +886,31 @@ func TestProposalsQuery(t *testing.T) {
 
 	// Test query all proposals
 	proposals = getProposalsAll(t, port)
-	require.Equal(t, proposalID1, (proposals[0]).GetProposalID())
-	require.Equal(t, proposalID2, (proposals[1]).GetProposalID())
-	require.Equal(t, proposalID3, (proposals[2]).GetProposalID())
+	require.Equal(t, proposalID1, (proposals[0]).ProposalID)
+	require.Equal(t, proposalID2, (proposals[1]).ProposalID)
+	require.Equal(t, proposalID3, (proposals[2]).ProposalID)
 
 	// Test query deposited by addr1
 	proposals = getProposalsFilterDepositor(t, port, addrs[0])
-	require.Equal(t, proposalID1, (proposals[0]).GetProposalID())
+	require.Equal(t, proposalID1, (proposals[0]).ProposalID)
 
 	// Test query deposited by addr2
 	proposals = getProposalsFilterDepositor(t, port, addrs[1])
-	require.Equal(t, proposalID2, (proposals[0]).GetProposalID())
-	require.Equal(t, proposalID3, (proposals[1]).GetProposalID())
+	require.Equal(t, proposalID2, (proposals[0]).ProposalID)
+	require.Equal(t, proposalID3, (proposals[1]).ProposalID)
 
 	// Test query voted by addr1
 	proposals = getProposalsFilterVoter(t, port, addrs[0])
-	require.Equal(t, proposalID2, (proposals[0]).GetProposalID())
-	require.Equal(t, proposalID3, (proposals[1]).GetProposalID())
+	require.Equal(t, proposalID2, (proposals[0]).ProposalID)
+	require.Equal(t, proposalID3, (proposals[1]).ProposalID)
 
 	// Test query voted by addr2
 	proposals = getProposalsFilterVoter(t, port, addrs[1])
-	require.Equal(t, proposalID3, (proposals[0]).GetProposalID())
+	require.Equal(t, proposalID3, (proposals[0]).ProposalID)
 
 	// Test query voted and deposited by addr1
 	proposals = getProposalsFilterVoterDepositor(t, port, addrs[0], addrs[0])
-	require.Equal(t, proposalID2, (proposals[0]).GetProposalID())
+	require.Equal(t, proposalID2, (proposals[0]).ProposalID)
 
 	// Test query votes on Proposal 2
 	votes := getVotes(t, port, proposalID2)
@@ -1008,3 +1019,29 @@ func TestDistributionFlow(t *testing.T) {
 	resultTx = doWithdrawDelegatorAllRewards(t, port, seed, name1, pw, addr, fees)
 	require.Equal(t, uint32(0), resultTx.Code)
 }
+
+func TestMintingQueries(t *testing.T) {
+	kb, err := keys.NewKeyBaseFromDir(InitClientHome(t, ""))
+	require.NoError(t, err)
+	addr, _ := CreateAddr(t, name1, pw, kb)
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
+	defer cleanup()
+
+	res, body := Request(t, port, "GET", "/minting/parameters", nil)
+	require.Equal(t, http.StatusOK, res.StatusCode, body)
+
+	var params mint.Params
+	require.NoError(t, cdc.UnmarshalJSON([]byte(body), &params))
+
+	res, body = Request(t, port, "GET", "/minting/inflation", nil)
+	require.Equal(t, http.StatusOK, res.StatusCode, body)
+
+	var inflation sdk.Dec
+	require.NoError(t, cdc.UnmarshalJSON([]byte(body), &inflation))
+
+	res, body = Request(t, port, "GET", "/minting/annual-provisions", nil)
+	require.Equal(t, http.StatusOK, res.StatusCode, body)
+
+	var annualProvisions sdk.Dec
+	require.NoError(t, cdc.UnmarshalJSON([]byte(body), &annualProvisions))
+}
diff --git a/client/lcd/root.go b/client/lcd/root.go
index 0f6fb120a..3a5144a2a 100644
--- a/client/lcd/root.go
+++ b/client/lcd/root.go
@@ -52,61 +52,27 @@ func NewRestServer(cdc *codec.Codec) *RestServer {
 }
 
 // Start starts the rest server
-func (rs *RestServer) Start(listenAddr string, sslHosts string,
-	certFile string, keyFile string, maxOpen int, secure bool) (err error) {
-
+func (rs *RestServer) Start(listenAddr string, maxOpen int) (err error) {
 	server.TrapSignal(func() {
 		err := rs.listener.Close()
 		rs.log.Error("error closing listener", "err", err)
 	})
 
-	rs.listener, err = rpcserver.Listen(
-		listenAddr,
-		rpcserver.Config{MaxOpenConnections: maxOpen},
-	)
+	cfg := rpcserver.DefaultConfig()
+	cfg.MaxOpenConnections = maxOpen
+
+	rs.listener, err = rpcserver.Listen(listenAddr, cfg)
 	if err != nil {
 		return
 	}
-	rs.log.Info(fmt.Sprintf("Starting Gaia Lite REST service (chain-id: %q)...",
-		viper.GetString(client.FlagChainID)))
-
-	// launch rest-server in insecure mode
-	if !secure {
-		return rpcserver.StartHTTPServer(rs.listener, rs.Mux, rs.log)
-	}
-
-	// handle certificates
-	if certFile != "" {
-		// validateCertKeyFiles() is needed to work around tendermint/tendermint#2460
-		if err := validateCertKeyFiles(certFile, keyFile); err != nil {
-			return err
-		}
-
-		//  cert/key pair is provided, read the fingerprint
-		rs.fingerprint, err = fingerprintFromFile(certFile)
-		if err != nil {
-			return err
-		}
-	} else {
-		// if certificate is not supplied, generate a self-signed one
-		certFile, keyFile, rs.fingerprint, err = genCertKeyFilesAndReturnFingerprint(sslHosts)
-		if err != nil {
-			return err
-		}
-
-		defer func() {
-			os.Remove(certFile)
-			os.Remove(keyFile)
-		}()
-	}
-
-	rs.log.Info(rs.fingerprint)
-	return rpcserver.StartHTTPAndTLSServer(
-		rs.listener,
-		rs.Mux,
-		certFile, keyFile,
-		rs.log,
+	rs.log.Info(
+		fmt.Sprintf(
+			"Starting Gaia Lite REST service (chain-id: %q)...",
+			viper.GetString(client.FlagChainID),
+		),
 	)
+
+	return rpcserver.StartHTTPServer(rs.listener, rs.Mux, rs.log, cfg)
 }
 
 // ServeCommand will start a Gaia Lite REST service as a blocking process. It
@@ -122,13 +88,8 @@ func ServeCommand(cdc *codec.Codec, registerRoutesFn func(*RestServer)) *cobra.C
 			registerRoutesFn(rs)
 
 			// Start the rest server and return error if one exists
-			err = rs.Start(
-				viper.GetString(client.FlagListenAddr),
-				viper.GetString(client.FlagSSLHosts),
-				viper.GetString(client.FlagSSLCertFile),
-				viper.GetString(client.FlagSSLKeyFile),
-				viper.GetInt(client.FlagMaxOpenConnections),
-				viper.GetBool(client.FlagTLS))
+			err = rs.Start(viper.GetString(client.FlagListenAddr),
+				viper.GetInt(client.FlagMaxOpenConnections))
 
 			return err
 		},
diff --git a/client/lcd/swagger-ui/swagger.yaml b/client/lcd/swagger-ui/swagger.yaml
index 0c6b78da8..cb479a63f 100644
--- a/client/lcd/swagger-ui/swagger.yaml
+++ b/client/lcd/swagger-ui/swagger.yaml
@@ -21,7 +21,7 @@ tags:
     description: Query app version
 schemes:
   - https
-host: fabo.interblock.io:1317
+host: stargate.cosmos.network
 securityDefinitions:
   kms:
     type: basic
@@ -65,6 +65,17 @@ paths:
               moniker:
                 type: string
                 example: validator-name
+              protocol_version:
+                properties:
+                  p2p:
+                    type: string
+                    example: 7
+                  block:
+                    type: string
+                    example: 10
+                  app:
+                    type: string
+                    example: 0
               network:
                 type: string
                 example: gaia-2
@@ -79,9 +90,14 @@ paths:
                 example: 0.15.0
               other:
                 description: more information on versions
-                type: array
-                items:
-                  type: string
+                type: object
+                properties:
+                  tx_index:
+                    type: string
+                    example: on
+                  rpc_address:
+                    type: string
+                    example: tcp://0.0.0.0:26657
         500:
           description: Failed to query node status
   /syncing:
@@ -122,6 +138,7 @@ paths:
           description: Block height
           required: true
           type: number
+          x-example: 1
       responses:
         200:
           description: The block at a specific height
@@ -167,6 +184,7 @@ paths:
           description: Block height
           required: true
           type: number
+          x-example: 1
       responses:
         200:
           description: The validator set at a specific block height
@@ -198,6 +216,7 @@ paths:
           description: Tx hash
           required: true
           type: string
+          x-example: 88D6B85EAB87D43CDF50F39C22FC2237A37FEDC4CE723200AD0AF48CBEDBC317
       responses:
         200:
           description: Tx with the provided hash
@@ -219,14 +238,17 @@ paths:
           type: string
           description: "transaction tags such as 'action=submit-proposal' and 'proposer=cosmos1g9ahr6xhht5rmqven628nklxluzyv8z9jqjcmc' which results in the following endpoint: 'GET /txs?action=submit-proposal&proposer=cosmos1g9ahr6xhht5rmqven628nklxluzyv8z9jqjcmc'"
           required: true
+          x-example: 'TODO'
         - in: query
           name: page
-          description: Pagination page
+          description: Page number
           type: integer
+          x-example: 1
         - in: query
-          name: size
-          description: Pagination size
+          name: limit
+          description: Maximum number of items per page
           type: integer
+          x-example: 1
       responses:
         200:
           description: All txs matching the provided tags
@@ -250,14 +272,14 @@ paths:
       parameters:
         - in: body
           name: txBroadcast
-          description: The tx must be a signed StdTx. The supported return types includes `"block"`(return after tx commit), `"sync"`(return afer CheckTx) and `"async"`(return right away).
+          description: The tx must be a signed StdTx. The supported broadcast modes include `"block"`(return after tx commit), `"sync"`(return afer CheckTx) and `"async"`(return right away).
           required: true
           schema:
             type: object
             properties:
               tx:
                 $ref: "#/definitions/StdTx"
-              return:
+              mode:
                 type: string
                 example: block
       responses:
@@ -313,6 +335,7 @@ paths:
           description: Account address in bech32 format
           required: true
           type: string
+          x-example: cosmos16gdxm24ht2mxtpz9cma6tr6a6d47x63hlq4pxt
       responses:
         200:
           description: Account balances
@@ -339,6 +362,7 @@ paths:
           description: Account address in bech32 format
           required: true
           type: string
+          x-example: cosmos16gdxm24ht2mxtpz9cma6tr6a6d47x63hlq4pxt
         - in: body
           name: account
           description: The sender and tx information
@@ -374,6 +398,7 @@ paths:
           description: Account address
           required: true
           type: string
+          x-example: cosmos16gdxm24ht2mxtpz9cma6tr6a6d47x63hlq4pxt
       responses:
         200:
           description: Account information on the blockchain
@@ -408,6 +433,7 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
     get:
       summary: Get all delegations from a delegator
       tags:
@@ -466,11 +492,13 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
       - in: path
         name: validatorAddr
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Query the current delegation between a delegator and a validator
       tags:
@@ -493,6 +521,7 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
     get:
       summary: Get all unbonding delegations from a delegator
       tags:
@@ -552,11 +581,13 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
       - in: path
         name: validatorAddr
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Query all unbonding delegations between a delegator and a validator
       tags:
@@ -613,6 +644,7 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
     post:
       summary: Submit a redelegation
       parameters:
@@ -655,6 +687,7 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
     get:
       summary: Query all validators that a delegator is bonded to
       tags:
@@ -679,11 +712,13 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
       - in: path
         name: validatorAddr
         description: Bech32 ValAddress of Delegator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Query a validator that a delegator is bonded to
       tags:
@@ -706,6 +741,7 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
     get:
       summary: Get all staking txs (i.e msgs) from a delegator
       tags:
@@ -748,6 +784,7 @@ paths:
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Query the information from a single validator
       tags:
@@ -770,6 +807,7 @@ paths:
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Get all delegations from a validator
       tags:
@@ -794,6 +832,7 @@ paths:
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Get all unbonding delegations from a validator
       tags:
@@ -881,26 +920,52 @@ paths:
           name: validatorPubKey
           required: true
           in: path
+          x-example: cosmosvalconspub1zcjduepq7mft6gfls57a0a42d7uhx656cckhfvtrlmw744jv4q0mvlv0dypskehfk8
       responses:
         200:
           description: OK
           schema:
-            type: object
-            properties:
-              start_height:
-                type: string
-              index_offset:
-                type: string
-              jailed_until:
-                type: string
-              missed_blocks_counter:
-                type: string
+            $ref: "#/definitions/SigningInfo"
         204:
           description: No sign info of this validator
         400:
           description: Invalid validator public key
         500:
           description: Internal Server Error
+  /slashing/signing_infos:
+    get:
+      summary: Get sign info of given all validators
+      description: Get sign info of all validators
+      produces:
+        - application/json
+      tags:
+        - ICS23
+      parameters:
+        - in: query
+          name: page
+          description: Page number
+          type: integer
+          required: true
+          x-example: 1
+        - in: query
+          name: limit
+          description: Maximum number of items per page
+          type: integer
+          required: true
+          x-example: 5
+      responses:
+        200:
+          description: OK
+          schema:
+            type: array
+            items:
+              $ref: "#/definitions/SigningInfo"
+        204:
+          description: No validators with sign info
+        400:
+          description: Invalid validator public key for one of the validators
+        500:
+          description: Internal Server Error
   /slashing/validators/{validatorAddr}/unjail:
     post:
       summary: Unjail a jailed validator
@@ -917,6 +982,7 @@ paths:
           name: validatorAddr
           required: true
           in: path
+          x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
         - description: ""
           name: UnjailBody
           in: body
@@ -1053,6 +1119,7 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
       responses:
         200:
           description: OK
@@ -1075,6 +1142,7 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
       responses:
         200:
           description: OK
@@ -1097,6 +1165,7 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
       responses:
         200:
           description: OK
@@ -1123,6 +1192,7 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
         - description: ""
           name: post_deposit_body
           in: body
@@ -1163,11 +1233,13 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
         - type: string
           description: Bech32 depositor address
           name: depositor
           required: true
           in: path
+          x-example: cosmos1xl6453f6q6dv5770c9ue6hspdc0vxfuqtudkhz
       responses:
         200:
           description: OK
@@ -1193,6 +1265,7 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
       responses:
         200:
           description: OK
@@ -1219,6 +1292,7 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
         - description: valid value of `"option"` field can be `"yes"`, `"no"`, `"no_with_veto"` and `"abstain"`
           name: post_vote_body
           in: body
@@ -1258,11 +1332,13 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
         - type: string
           description: Bech32 voter address
           name: voter
           required: true
           in: path
+          x-example: cosmos1qwl879nx9t6kef4supyazayf7vjhennyjqwjgr
       responses:
         200:
           description: OK
@@ -1288,6 +1364,7 @@ paths:
           name: proposalId
           required: true
           in: path
+          x-example: '1'
       responses:
         200:
           description: OK
@@ -1381,6 +1458,7 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
     get:
       summary: Get the total rewards balance from all delegations
       description: Get the sum of all the rewards earned by delegations by a single delegator
@@ -1433,11 +1511,13 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
       - in: path
         name: validatorAddr
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Query a delegation reward
       description: Query a single delegation reward by a delegator
@@ -1490,6 +1570,7 @@ paths:
         description: Bech32 AccAddress of Delegator
         required: true
         type: string
+        x-example: cosmos167w96tdvmazakdwkw2u57227eduula2cy572lf
     get:
       summary: Get the rewards withdrawal address
       description: Get the delegations' rewards withdrawal address. This is the address in which the user will receive the reward funds
@@ -1542,6 +1623,7 @@ paths:
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Validator distribution information
       description: Query the distribution information of a single validator
@@ -1565,21 +1647,22 @@ paths:
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
-     summary: Fee distribution outstanding rewards of a single validator
-     tags:
-       - ICS24
-     produces:
-       - application/json
-     responses:
-       200:
-         description: OK
-         schema:
-           type: array
-           items:
-             $ref: "#/definitions/Coin"
-       500:
-         description: Internal Server Error
+      summary: Fee distribution outstanding rewards of a single validator
+      tags:
+        - ICS24
+      produces:
+        - application/json
+      responses:
+        200:
+          description: OK
+          schema:
+            type: array
+            items:
+              $ref: "#/definitions/Coin"
+        500:
+          description: Internal Server Error
   /distribution/validators/{validatorAddr}/rewards:
     parameters:
       - in: path
@@ -1587,6 +1670,7 @@ paths:
         description: Bech32 OperatorAddress of validator
         required: true
         type: string
+        x-example: cosmosvaloper1qwl879nx9t6kef4supyazayf7vjhennyh568ys
     get:
       summary: Commission and self-delegation rewards of a single validator
       description: Query the commission and self-delegation rewards of validator.
@@ -1632,6 +1716,22 @@ paths:
           description: Key password is wrong
         500:
           description: Internal Server Error
+  /distribution/community_pool:
+    get:
+      summary: Community pool parameters
+      tags:
+        - ICS24
+      produces:
+        - application/json
+      responses:
+        200:
+          description: OK
+          schema:
+            type: array
+            items:
+              $ref: "#/definitions/Coin"
+        500:
+          description: Internal Server Error
   /distribution/parameters:
     get:
       summary: Fee distribution parameters
@@ -1652,6 +1752,54 @@ paths:
                 type: string
         500:
           description: Internal Server Error
+  /minting/parameters:
+    get:
+      summary: Minting module parameters
+      produces:
+        - application/json
+      responses:
+        200:
+          description: OK
+          schema:
+            properties:
+              mint_denom:
+                type: string
+              inflation_rate_change:
+                type: string
+              inflation_max:
+                type: string
+              inflation_min:
+                type: string
+              goal_bonded:
+                type: string
+              blocks_per_year:
+                type: integer
+        500:
+          description: Internal Server Error
+  /minting/inflation:
+    get:
+      summary: Current minting inflation value
+      produces:
+        - application/json
+      responses:
+        200:
+          description: OK
+          schema:
+            type: string
+        500:
+          description: Internal Server Error
+  /minting/annual-provisions:
+    get:
+      summary: Current minting annual provisions value
+      produces:
+        - application/json
+      responses:
+        200:
+          description: OK
+          schema:
+            type: string
+        500:
+          description: Internal Server Error
 definitions:
   CheckTxResult:
     type: object
@@ -1744,7 +1892,7 @@ definitions:
     properties:
       denom:
         type: string
-        example: steak
+        example: stake
       amount:
         type: string
         example: "50"
@@ -1882,6 +2030,15 @@ definitions:
         $ref: "#/definitions/Hash"
       proposer_address:
         $ref: "#/definitions/Address"
+      version:
+        type: object
+        properties:
+          block:
+            type: string
+            example: 10
+          app:
+            type: string
+            example: 0
   Block:
     type: object
     properties:
@@ -1980,7 +2137,7 @@ definitions:
       pub_key:
         type: string
         example: cosmosvalconspub1zcjduepq7sjfglw7ra4mjxpw4ph7dtdhdheh7nz8dfgl6t8u2n5szuuql9mqsrwquu
-      power:
+      voting_power:
         type: string
         example: "1000"
       proposer_priority:
@@ -2165,3 +2322,14 @@ definitions:
         type: array
         items:
           $ref: "#/definitions/Coin"
+  SigningInfo:
+    type: object
+    properties:
+      start_height:
+        type: string
+      index_offset:
+        type: string
+      jailed_until:
+        type: string
+      missed_blocks_counter:
+        type: string
diff --git a/client/lcd/test_helpers.go b/client/lcd/test_helpers.go
index 507c6af03..856efaf95 100644
--- a/client/lcd/test_helpers.go
+++ b/client/lcd/test_helpers.go
@@ -42,6 +42,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	govrest "github.com/cosmos/cosmos-sdk/x/gov/client/rest"
 	gcutils "github.com/cosmos/cosmos-sdk/x/gov/client/utils"
+	mintrest "github.com/cosmos/cosmos-sdk/x/mint/client/rest"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
 	slashingrest "github.com/cosmos/cosmos-sdk/x/slashing/client/rest"
 	"github.com/cosmos/cosmos-sdk/x/staking"
@@ -198,7 +199,7 @@ func InitClientHome(t *testing.T, dir string) string {
 // TODO: Make InitializeTestLCD safe to call in multiple tests at the same time
 // InitializeTestLCD starts Tendermint and the LCD in process, listening on
 // their respective sockets where nValidators is the total number of validators
-// and initAddrs are the accounts to initialize with some steak tokens. It
+// and initAddrs are the accounts to initialize with some stake tokens. It
 // returns a cleanup function, a set of validator public keys, and a port.
 func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress, minting bool) (
 	cleanup func(), valConsPubKeys []crypto.PubKey, valOperAddrs []sdk.ValAddress, port string) {
@@ -220,14 +221,14 @@ func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress
 	privVal.Reset()
 
 	db := dbm.NewMemDB()
-	app := gapp.NewGaiaApp(logger, db, nil, true)
+	app := gapp.NewGaiaApp(logger, db, nil, true, false)
 	cdc = gapp.MakeCodec()
 
 	genesisFile := config.GenesisFile()
 	genDoc, err := tmtypes.GenesisDocFromFile(genesisFile)
 	require.Nil(t, err)
 	genDoc.Validators = nil
-	genDoc.SaveAs(genesisFile)
+	require.NoError(t, genDoc.SaveAs(genesisFile))
 	genTxs := []json.RawMessage{}
 
 	// append any additional (non-proposing) validators
@@ -299,6 +300,9 @@ func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress
 	genesisState.MintData.Minter.Inflation = inflationMin
 	genesisState.MintData.Params.InflationMin = inflationMin
 
+	// initialize crisis data
+	genesisState.CrisisData.ConstantFee = sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000)
+
 	// double check inflation is set according to the minting boolean flag
 	if minting {
 		require.Equal(t, sdk.MustNewDecFromStr("15000.0"),
@@ -337,7 +341,7 @@ func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress
 
 	cleanup = func() {
 		logger.Debug("cleaning up LCD initialization")
-		node.Stop()
+		node.Stop() //nolint:errcheck
 		node.Wait()
 		lcd.Close()
 	}
@@ -390,11 +394,11 @@ func startTM(
 func startLCD(logger log.Logger, listenAddr string, cdc *codec.Codec, t *testing.T) (net.Listener, error) {
 	rs := NewRestServer(cdc)
 	registerRoutes(rs)
-	listener, err := tmrpc.Listen(listenAddr, tmrpc.Config{})
+	listener, err := tmrpc.Listen(listenAddr, tmrpc.DefaultConfig())
 	if err != nil {
 		return nil, err
 	}
-	go tmrpc.StartHTTPServer(listener, rs.Mux, logger)
+	go tmrpc.StartHTTPServer(listener, rs.Mux, logger, tmrpc.DefaultConfig()) //nolint:errcheck
 	return listener, nil
 }
 
@@ -408,6 +412,7 @@ func registerRoutes(rs *RestServer) {
 	stakingrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
 	slashingrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
 	govrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
+	mintrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
 }
 
 // Request makes a test LCD test request. It returns a response object and a
@@ -559,7 +564,7 @@ func getKeys(t *testing.T, port string) []keys.KeyOutput {
 
 // POST /keys Create a new account locally
 func doKeysPost(t *testing.T, port, name, password, mnemonic string, account int, index int) keys.KeyOutput {
-	pk := clientkeys.AddNewKey{name, password, mnemonic, account, index}
+	pk := clientkeys.NewAddNewKey(name, password, mnemonic, account, index)
 	req, err := cdc.MarshalJSON(pk)
 	require.NoError(t, err)
 
@@ -585,7 +590,7 @@ func getKeysSeed(t *testing.T, port string) string {
 
 // POST /keys/{name}/recove Recover a account from a seed
 func doRecoverKey(t *testing.T, port, recoverName, recoverPassword, mnemonic string, account uint32, index uint32) {
-	pk := clientkeys.RecoverKey{recoverPassword, mnemonic, int(account), int(index)}
+	pk := clientkeys.NewRecoverKey(recoverPassword, mnemonic, int(account), int(index))
 	req, err := cdc.MarshalJSON(pk)
 	require.NoError(t, err)
 
@@ -613,7 +618,7 @@ func getKey(t *testing.T, port, name string) keys.KeyOutput {
 
 // PUT /keys/{name} Update the password for this account in the KMS
 func updateKey(t *testing.T, port, name, oldPassword, newPassword string, fail bool) {
-	kr := clientkeys.UpdateKeyReq{oldPassword, newPassword}
+	kr := clientkeys.NewUpdateKeyReq(oldPassword, newPassword)
 	req, err := cdc.MarshalJSON(kr)
 	require.NoError(t, err)
 	keyEndpoint := fmt.Sprintf("/keys/%s", name)
@@ -627,7 +632,7 @@ func updateKey(t *testing.T, port, name, oldPassword, newPassword string, fail b
 
 // DELETE /keys/{name} Remove an account
 func deleteKey(t *testing.T, port, name, password string) {
-	dk := clientkeys.DeleteKeyReq{password}
+	dk := clientkeys.NewDeleteKeyReq(password)
 	req, err := cdc.MarshalJSON(dk)
 	require.NoError(t, err)
 	keyEndpoint := fmt.Sprintf("/keys/%s", name)
@@ -651,7 +656,7 @@ func getAccount(t *testing.T, port string, addr sdk.AccAddress) auth.Account {
 
 // POST /tx/broadcast Send a signed Tx
 func doBroadcast(t *testing.T, port string, tx auth.StdTx) (*http.Response, string) {
-	txReq := clienttx.BroadcastReq{Tx: tx, Return: "block"}
+	txReq := clienttx.BroadcastReq{Tx: tx, Mode: "block"}
 
 	req, err := cdc.MarshalJSON(txReq)
 	require.Nil(t, err)
@@ -668,7 +673,7 @@ func doTransfer(
 	resp, body, recvAddr := doTransferWithGas(
 		t, port, seed, name, memo, pwd, addr, "", 1.0, false, true, fees,
 	)
-	require.Equal(t, http.StatusOK, resp.StatusCode, resp)
+	require.Equal(t, http.StatusOK, resp.StatusCode, body)
 
 	var txResp sdk.TxResponse
 	err := cdc.UnmarshalJSON([]byte(body), &txResp)
@@ -815,11 +820,11 @@ func doDelegate(
 	from := acc.GetAddress().String()
 
 	baseReq := rest.NewBaseReq(from, "", chainID, "", "", accnum, sequence, fees, nil, false)
-	msg := msgDelegationsInput{
+	msg := stakingrest.DelegateRequest{
 		BaseReq:          baseReq,
 		DelegatorAddress: delAddr,
 		ValidatorAddress: valAddr,
-		Delegation:       sdk.NewCoin(sdk.DefaultBondDenom, amount),
+		Amount:           sdk.NewCoin(sdk.DefaultBondDenom, amount),
 	}
 
 	req, err := cdc.MarshalJSON(msg)
@@ -839,13 +844,6 @@ func doDelegate(
 	return txResp
 }
 
-type msgDelegationsInput struct {
-	BaseReq          rest.BaseReq   `json:"base_req"`
-	DelegatorAddress sdk.AccAddress `json:"delegator_address"` // in bech32
-	ValidatorAddress sdk.ValAddress `json:"validator_address"` // in bech32
-	Delegation       sdk.Coin       `json:"delegation"`
-}
-
 // POST /staking/delegators/{delegatorAddr}/delegations Submit delegation
 func doUndelegate(
 	t *testing.T, port, name, pwd string, delAddr sdk.AccAddress,
@@ -859,11 +857,11 @@ func doUndelegate(
 	from := acc.GetAddress().String()
 
 	baseReq := rest.NewBaseReq(from, "", chainID, "", "", accnum, sequence, fees, nil, false)
-	msg := msgUndelegateInput{
+	msg := stakingrest.UndelegateRequest{
 		BaseReq:          baseReq,
 		DelegatorAddress: delAddr,
 		ValidatorAddress: valAddr,
-		SharesAmount:     amount.ToDec(),
+		Amount:           sdk.NewCoin(sdk.DefaultBondDenom, amount),
 	}
 
 	req, err := cdc.MarshalJSON(msg)
@@ -882,13 +880,6 @@ func doUndelegate(
 	return txResp
 }
 
-type msgUndelegateInput struct {
-	BaseReq          rest.BaseReq   `json:"base_req"`
-	DelegatorAddress sdk.AccAddress `json:"delegator_address"` // in bech32
-	ValidatorAddress sdk.ValAddress `json:"validator_address"` // in bech32
-	SharesAmount     sdk.Dec        `json:"shares"`
-}
-
 // POST /staking/delegators/{delegatorAddr}/delegations Submit delegation
 func doBeginRedelegation(
 	t *testing.T, port, name, pwd string, delAddr sdk.AccAddress, valSrcAddr,
@@ -902,12 +893,12 @@ func doBeginRedelegation(
 	from := acc.GetAddress().String()
 
 	baseReq := rest.NewBaseReq(from, "", chainID, "", "", accnum, sequence, fees, nil, false)
-	msg := stakingrest.MsgBeginRedelegateInput{
+	msg := stakingrest.RedelegateRequest{
 		BaseReq:             baseReq,
 		DelegatorAddress:    delAddr,
 		ValidatorSrcAddress: valSrcAddr,
 		ValidatorDstAddress: valDstAddr,
-		SharesAmount:        amount.ToDec(),
+		Amount:              sdk.NewCoin(sdk.DefaultBondDenom, amount),
 	}
 
 	req, err := cdc.MarshalJSON(msg)
@@ -926,14 +917,6 @@ func doBeginRedelegation(
 	return txResp
 }
 
-type msgBeginRedelegateInput struct {
-	BaseReq             rest.BaseReq   `json:"base_req"`
-	DelegatorAddress    sdk.AccAddress `json:"delegator_address"`     // in bech32
-	ValidatorSrcAddress sdk.ValAddress `json:"validator_src_address"` // in bech32
-	ValidatorDstAddress sdk.ValAddress `json:"validator_dst_address"` // in bech32
-	SharesAmount        sdk.Dec        `json:"shares"`
-}
-
 // GET /staking/delegators/{delegatorAddr}/delegations Get all delegations from a delegator
 func getDelegatorDelegations(t *testing.T, port string, delegatorAddr sdk.AccAddress) []staking.Delegation {
 	res, body := Request(t, port, "GET", fmt.Sprintf("/staking/delegators/%s/delegations", delegatorAddr), nil)
@@ -1414,6 +1397,21 @@ func getSigningInfo(t *testing.T, port string, validatorPubKey string) slashing.
 	return signingInfo
 }
 
+// ----------------------------------------------------------------------
+// ICS 23 - SlashingList
+// ----------------------------------------------------------------------
+// GET /slashing/signing_infos Get sign info of all validators with pagination
+func getSigningInfoList(t *testing.T, port string) []slashing.ValidatorSigningInfo {
+	res, body := Request(t, port, "GET", "/slashing/signing_infos?page=1&limit=1", nil)
+	require.Equal(t, http.StatusOK, res.StatusCode, body)
+
+	var signingInfo []slashing.ValidatorSigningInfo
+	err := cdc.UnmarshalJSON([]byte(body), &signingInfo)
+	require.Nil(t, err)
+
+	return signingInfo
+}
+
 // TODO: Test this functionality, it is not currently in any of the tests
 // POST /slashing/validators/{validatorAddr}/unjail Unjail a jailed validator
 func doUnjail(
diff --git a/client/rest/rest.go b/client/rest/rest.go
index 81d2cc57b..709ef0d4a 100644
--- a/client/rest/rest.go
+++ b/client/rest/rest.go
@@ -1,6 +1,7 @@
 package rest
 
 import (
+	"log"
 	"net/http"
 
 	"github.com/cosmos/cosmos-sdk/client"
@@ -67,6 +68,8 @@ func WriteGenerateStdTxResponse(w http.ResponseWriter, cdc *codec.Codec,
 	}
 
 	w.Header().Set("Content-Type", "application/json")
-	w.Write(output)
+	if _, err := w.Write(output); err != nil {
+		log.Printf("could not write response: %v", err)
+	}
 	return
 }
diff --git a/client/rpc/block.go b/client/rpc/block.go
index 127e9c9c8..6d6e0a9fd 100644
--- a/client/rpc/block.go
+++ b/client/rpc/block.go
@@ -115,20 +115,19 @@ func BlockRequestHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
 		vars := mux.Vars(r)
 		height, err := strconv.ParseInt(vars["height"], 10, 64)
 		if err != nil {
-			w.WriteHeader(http.StatusBadRequest)
-			w.Write([]byte("ERROR: Couldn't parse block height. Assumed format is '/block/{height}'."))
+			rest.WriteErrorResponse(w, http.StatusBadRequest,
+				"ERROR: Couldn't parse block height. Assumed format is '/block/{height}'.")
 			return
 		}
 		chainHeight, err := GetChainHeight(cliCtx)
 		if height > chainHeight {
-			w.WriteHeader(http.StatusNotFound)
-			w.Write([]byte("ERROR: Requested block height is bigger then the chain length."))
+			rest.WriteErrorResponse(w, http.StatusNotFound,
+				"ERROR: Requested block height is bigger then the chain length.")
 			return
 		}
 		output, err := getBlock(cliCtx, &height)
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 		rest.PostProcessResponse(w, cdc, output, cliCtx.Indent)
@@ -140,14 +139,12 @@ func LatestBlockRequestHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		height, err := GetChainHeight(cliCtx)
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 		output, err := getBlock(cliCtx, &height)
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 		rest.PostProcessResponse(w, cdc, output, cliCtx.Indent)
diff --git a/client/rpc/root.go b/client/rpc/root.go
index 45533e3ea..fa82b493f 100644
--- a/client/rpc/root.go
+++ b/client/rpc/root.go
@@ -2,6 +2,7 @@ package rpc
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 
 	"github.com/gorilla/mux"
@@ -26,7 +27,9 @@ func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router) {
 // cli version REST handler endpoint
 func CLIVersionRequestHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
-	w.Write([]byte(fmt.Sprintf("{\"version\": \"%s\"}", version.Version)))
+	if _, err := w.Write([]byte(fmt.Sprintf("{\"version\": \"%s\"}", version.Version))); err != nil {
+		log.Printf("could not write response: %v", err)
+	}
 }
 
 // connected node version REST handler endpoint
@@ -39,6 +42,8 @@ func NodeVersionRequestHandler(cliCtx context.CLIContext) http.HandlerFunc {
 		}
 
 		w.Header().Set("Content-Type", "application/json")
-		w.Write(version)
+		if _, err := w.Write(version); err != nil {
+			log.Printf("could not write response: %v", err)
+		}
 	}
 }
diff --git a/client/rpc/status.go b/client/rpc/status.go
index e017fa860..e96889a78 100644
--- a/client/rpc/status.go
+++ b/client/rpc/status.go
@@ -2,6 +2,7 @@ package rpc
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 	"strconv"
 
@@ -71,8 +72,7 @@ func NodeInfoRequestHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		status, err := getNodeStatus(cliCtx)
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 
@@ -86,18 +86,18 @@ func NodeSyncingRequestHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		status, err := getNodeStatus(cliCtx)
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 
 		syncing := status.SyncInfo.CatchingUp
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 
-		w.Write([]byte(strconv.FormatBool(syncing)))
+		if _, err := w.Write([]byte(strconv.FormatBool(syncing))); err != nil {
+			log.Printf("could not write response: %v", err)
+		}
 	}
 }
diff --git a/client/rpc/validators.go b/client/rpc/validators.go
index 90389bf64..0c81f8151 100644
--- a/client/rpc/validators.go
+++ b/client/rpc/validators.go
@@ -45,7 +45,7 @@ func ValidatorCommand(cdc *codec.Codec) *cobra.Command {
 
 			cliCtx := context.NewCLIContext().WithCodec(cdc)
 
-			result, err := getValidators(cliCtx, height)
+			result, err := GetValidators(cliCtx, height)
 			if err != nil {
 				return err
 			}
@@ -113,7 +113,7 @@ func bech32ValidatorOutput(validator *tmtypes.Validator) (ValidatorOutput, error
 	}, nil
 }
 
-func getValidators(cliCtx context.CLIContext, height *int64) (ResultValidatorsOutput, error) {
+func GetValidators(cliCtx context.CLIContext, height *int64) (ResultValidatorsOutput, error) {
 	// get the node
 	node, err := cliCtx.GetNode()
 	if err != nil {
@@ -160,22 +160,19 @@ func ValidatorSetRequestHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
 
 		height, err := strconv.ParseInt(vars["height"], 10, 64)
 		if err != nil {
-			w.WriteHeader(http.StatusBadRequest)
-			w.Write([]byte("ERROR: Couldn't parse block height. Assumed format is '/validatorsets/{height}'."))
+			rest.WriteErrorResponse(w, http.StatusBadRequest, "ERROR: Couldn't parse block height. Assumed format is '/validatorsets/{height}'.")
 			return
 		}
 
 		chainHeight, err := GetChainHeight(cliCtx)
 		if height > chainHeight {
-			w.WriteHeader(http.StatusNotFound)
-			w.Write([]byte("ERROR: Requested block height is bigger then the chain length."))
+			rest.WriteErrorResponse(w, http.StatusNotFound, "ERROR: Requested block height is bigger then the chain length.")
 			return
 		}
 
-		output, err := getValidators(cliCtx, &height)
+		output, err := GetValidators(cliCtx, &height)
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 		rest.PostProcessResponse(w, cdc, output, cliCtx.Indent)
@@ -187,15 +184,13 @@ func LatestValidatorSetRequestHandlerFn(cliCtx context.CLIContext) http.HandlerF
 	return func(w http.ResponseWriter, r *http.Request) {
 		height, err := GetChainHeight(cliCtx)
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 
-		output, err := getValidators(cliCtx, &height)
+		output, err := GetValidators(cliCtx, &height)
 		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 		rest.PostProcessResponse(w, cdc, output, cliCtx.Indent)
diff --git a/client/tx/broadcast.go b/client/tx/broadcast.go
index a0437b1cd..15afff00f 100644
--- a/client/tx/broadcast.go
+++ b/client/tx/broadcast.go
@@ -18,19 +18,10 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 )
 
-const (
-	// Returns with the response from CheckTx.
-	flagSync = "sync"
-	// Returns right away, with no response
-	flagAsync = "async"
-	// Only returns error if mempool.BroadcastTx errs (ie. problem with the app) or if we timeout waiting for tx to commit.
-	flagBlock = "block"
-)
-
 // BroadcastReq defines a tx broadcasting request.
 type BroadcastReq struct {
-	Tx     auth.StdTx `json:"tx"`
-	Return string     `json:"return"`
+	Tx   auth.StdTx `json:"tx"`
+	Mode string     `json:"mode"`
 }
 
 // BroadcastTxRequest implements a tx broadcasting handler that is responsible
@@ -58,23 +49,9 @@ func BroadcastTxRequest(cliCtx context.CLIContext, cdc *codec.Codec) http.Handle
 			return
 		}
 
-		var res interface{}
-		switch req.Return {
-		case flagBlock:
-			res, err = cliCtx.BroadcastTx(txBytes)
-
-		case flagSync:
-			res, err = cliCtx.BroadcastTxSync(txBytes)
-
-		case flagAsync:
-			res, err = cliCtx.BroadcastTxAsync(txBytes)
-
-		default:
-			rest.WriteErrorResponse(w, http.StatusInternalServerError,
-				"unsupported return type. supported types: block, sync, async")
-			return
-		}
+		cliCtx = cliCtx.WithBroadcastMode(req.Mode)
 
+		res, err := cliCtx.BroadcastTx(txBytes)
 		if err != nil {
 			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
@@ -110,7 +87,7 @@ $ gaiacli tx broadcast ./mytxn.json
 			}
 
 			res, err := cliCtx.BroadcastTx(txBytes)
-			cliCtx.PrintOutput(res)
+			cliCtx.PrintOutput(res) // nolint:errcheck
 			return err
 		},
 	}
diff --git a/client/tx/encode.go b/client/tx/encode.go
index 75670aade..5ea64ea72 100644
--- a/client/tx/encode.go
+++ b/client/tx/encode.go
@@ -97,7 +97,7 @@ If you supply a dash (-) argument in place of an input filename, the command rea
 			txBytesBase64 := base64.StdEncoding.EncodeToString(txBytes)
 
 			response := txEncodeRespStr(txBytesBase64)
-			cliCtx.PrintOutput(response)
+			cliCtx.PrintOutput(response) // nolint:errcheck
 
 			return nil
 		},
diff --git a/client/tx/query.go b/client/tx/query.go
index 74bb38495..8bb8e10cd 100644
--- a/client/tx/query.go
+++ b/client/tx/query.go
@@ -1,14 +1,13 @@
 package tx
 
 import (
-	"encoding/hex"
 	"fmt"
 	"net/http"
 	"strings"
 
 	"github.com/gorilla/mux"
 	"github.com/spf13/cobra"
-	ctypes "github.com/tendermint/tendermint/rpc/core/types"
+	"github.com/tendermint/tendermint/types"
 
 	"github.com/spf13/viper"
 
@@ -17,14 +16,100 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/rest"
-	"github.com/cosmos/cosmos-sdk/x/auth"
 )
 
+const (
+	flagTags  = "tags"
+	flagPage  = "page"
+	flagLimit = "limit"
+)
+
+// ----------------------------------------------------------------------------
+// CLI
+// ----------------------------------------------------------------------------
+
+// SearchTxCmd returns a command to search through tagged transactions.
+func SearchTxCmd(cdc *codec.Codec) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "txs",
+		Short: "Search for paginated transactions that match a set of tags",
+		Long: strings.TrimSpace(`
+Search for transactions that match the exact given tags where results are paginated.
+
+Example:
+$ gaiacli query txs --tags '<tag1>:<value1>&<tag2>:<value2>' --page 1 --limit 30
+`),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			tagsStr := viper.GetString(flagTags)
+			tagsStr = strings.Trim(tagsStr, "'")
+
+			var tags []string
+			if strings.Contains(tagsStr, "&") {
+				tags = strings.Split(tagsStr, "&")
+			} else {
+				tags = append(tags, tagsStr)
+			}
+
+			var tmTags []string
+			for _, tag := range tags {
+				if !strings.Contains(tag, ":") {
+					return fmt.Errorf("%s should be of the format <key>:<value>", tagsStr)
+				} else if strings.Count(tag, ":") > 1 {
+					return fmt.Errorf("%s should only contain one <key>:<value> pair", tagsStr)
+				}
+
+				keyValue := strings.Split(tag, ":")
+				if keyValue[0] == types.TxHeightKey {
+					tag = fmt.Sprintf("%s=%s", keyValue[0], keyValue[1])
+				} else {
+					tag = fmt.Sprintf("%s='%s'", keyValue[0], keyValue[1])
+				}
+				tmTags = append(tmTags, tag)
+			}
+
+			page := viper.GetInt(flagPage)
+			limit := viper.GetInt(flagLimit)
+
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+			txs, err := SearchTxs(cliCtx, cdc, tmTags, page, limit)
+			if err != nil {
+				return err
+			}
+
+			var output []byte
+			if cliCtx.Indent {
+				output, err = cdc.MarshalJSONIndent(txs, "", "  ")
+			} else {
+				output, err = cdc.MarshalJSON(txs)
+			}
+
+			if err != nil {
+				return err
+			}
+
+			fmt.Println(string(output))
+			return nil
+		},
+	}
+
+	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
+	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
+	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+	viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
+
+	cmd.Flags().String(flagTags, "", "tag:value list of tags that must match")
+	cmd.Flags().Uint32(flagPage, rest.DefaultPage, "Query a specific page of paginated results")
+	cmd.Flags().Uint32(flagLimit, rest.DefaultLimit, "Query number of transactions results per page returned")
+	cmd.MarkFlagRequired(flagTags)
+
+	return cmd
+}
+
 // QueryTxCmd implements the default command for a tx query.
 func QueryTxCmd(cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "tx [hash]",
-		Short: "Matches this txhash over all committed blocks",
+		Short: "Find a transaction by hash in a committed block.",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			cliCtx := context.NewCLIContext().WithCodec(cdc)
@@ -46,76 +131,55 @@ func QueryTxCmd(cdc *codec.Codec) *cobra.Command {
 	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
 	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
 	viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
+
 	return cmd
 }
 
-func queryTx(cdc *codec.Codec, cliCtx context.CLIContext, hashHexStr string) (out sdk.TxResponse, err error) {
-	hash, err := hex.DecodeString(hashHexStr)
-	if err != nil {
-		return out, err
-	}
-
-	node, err := cliCtx.GetNode()
-	if err != nil {
-		return out, err
-	}
-
-	res, err := node.Tx(hash, !cliCtx.TrustNode)
-	if err != nil {
-		return out, err
-	}
-
-	if !cliCtx.TrustNode {
-		if err = ValidateTxResult(cliCtx, res); err != nil {
-			return out, err
-		}
-	}
-
-	if out, err = formatTxResult(cdc, res); err != nil {
-		return out, err
-	}
-
-	return out, nil
-}
-
-// ValidateTxResult performs transaction verification
-func ValidateTxResult(cliCtx context.CLIContext, res *ctypes.ResultTx) error {
-	if !cliCtx.TrustNode {
-		check, err := cliCtx.Verify(res.Height)
-		if err != nil {
-			return err
-		}
-		err = res.Proof.Validate(check.Header.DataHash)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func formatTxResult(cdc *codec.Codec, res *ctypes.ResultTx) (sdk.TxResponse, error) {
-	tx, err := parseTx(cdc, res.Tx)
-	if err != nil {
-		return sdk.TxResponse{}, err
-	}
-
-	return sdk.NewResponseResultTx(res, tx), nil
-}
-
-func parseTx(cdc *codec.Codec, txBytes []byte) (sdk.Tx, error) {
-	var tx auth.StdTx
-
-	err := cdc.UnmarshalBinaryLengthPrefixed(txBytes, &tx)
-	if err != nil {
-		return nil, err
-	}
-
-	return tx, nil
-}
-
+// ----------------------------------------------------------------------------
 // REST
+// ----------------------------------------------------------------------------
 
-// QueryTxRequestHandlerFn transaction query REST handler
+// QueryTxsByTagsRequestHandlerFn implements a REST handler that searches for
+// transactions by tags.
+func QueryTxsByTagsRequestHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var (
+			tags        []string
+			txs         []sdk.TxResponse
+			page, limit int
+		)
+
+		err := r.ParseForm()
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest,
+				sdk.AppendMsgToErr("could not parse query parameters", err.Error()))
+			return
+		}
+
+		if len(r.Form) == 0 {
+			rest.PostProcessResponse(w, cdc, txs, cliCtx.Indent)
+			return
+		}
+
+		tags, page, limit, err = rest.ParseHTTPArgs(r)
+
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		txs, err = SearchTxs(cliCtx, cdc, tags, page, limit)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		rest.PostProcessResponse(w, cdc, txs, cliCtx.Indent)
+	}
+}
+
+// QueryTxRequestHandlerFn implements a REST handler that queries a transaction
+// by hash in a committed block.
 func QueryTxRequestHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		vars := mux.Vars(r)
diff --git a/client/tx/root.go b/client/tx/root.go
index 104e0a57c..cb2c64609 100644
--- a/client/tx/root.go
+++ b/client/tx/root.go
@@ -10,7 +10,7 @@ import (
 // register REST routes
 func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec) {
 	r.HandleFunc("/txs/{hash}", QueryTxRequestHandlerFn(cdc, cliCtx)).Methods("GET")
-	r.HandleFunc("/txs", SearchTxRequestHandlerFn(cliCtx, cdc)).Methods("GET")
+	r.HandleFunc("/txs", QueryTxsByTagsRequestHandlerFn(cliCtx, cdc)).Methods("GET")
 	r.HandleFunc("/txs", BroadcastTxRequest(cliCtx, cdc)).Methods("POST")
 	r.HandleFunc("/txs/encode", EncodeTxRequestHandlerFn(cdc, cliCtx)).Methods("POST")
 }
diff --git a/client/tx/search.go b/client/tx/search.go
deleted file mode 100644
index 718ab5d03..000000000
--- a/client/tx/search.go
+++ /dev/null
@@ -1,250 +0,0 @@
-package tx
-
-import (
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"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/types/rest"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-
-	ctypes "github.com/tendermint/tendermint/rpc/core/types"
-	"github.com/tendermint/tendermint/types"
-)
-
-const (
-	flagTags     = "tags"
-	flagAny      = "any"
-	flagPage     = "page"
-	flagLimit    = "limit"
-	defaultPage  = 1
-	defaultLimit = 30 // should be consistent with tendermint/tendermint/rpc/core/pipe.go:19
-)
-
-// default client command to search through tagged transactions
-func SearchTxCmd(cdc *codec.Codec) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "txs",
-		Short: "Search for all transactions that match the given tags.",
-		Long: strings.TrimSpace(`
-Search for transactions that match exactly the given tags. For example:
-
-$ gaiacli query txs --tags '<tag1>:<value1>&<tag2>:<value2>' --page 1 --limit 30
-`),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			tagsStr := viper.GetString(flagTags)
-			tagsStr = strings.Trim(tagsStr, "'")
-			var tags []string
-			if strings.Contains(tagsStr, "&") {
-				tags = strings.Split(tagsStr, "&")
-			} else {
-				tags = append(tags, tagsStr)
-			}
-
-			var tmTags []string
-			for _, tag := range tags {
-				if !strings.Contains(tag, ":") {
-					return fmt.Errorf("%s should be of the format <key>:<value>", tagsStr)
-				} else if strings.Count(tag, ":") > 1 {
-					return fmt.Errorf("%s should only contain one <key>:<value> pair", tagsStr)
-				}
-
-				keyValue := strings.Split(tag, ":")
-				if keyValue[0] == types.TxHeightKey {
-					tag = fmt.Sprintf("%s=%s", keyValue[0], keyValue[1])
-				} else {
-					tag = fmt.Sprintf("%s='%s'", keyValue[0], keyValue[1])
-				}
-				tmTags = append(tmTags, tag)
-			}
-			page := viper.GetInt(flagPage)
-			limit := viper.GetInt(flagLimit)
-
-			cliCtx := context.NewCLIContext().WithCodec(cdc)
-			txs, err := SearchTxs(cliCtx, cdc, tmTags, page, limit)
-			if err != nil {
-				return err
-			}
-
-			var output []byte
-			if cliCtx.Indent {
-				output, err = cdc.MarshalJSONIndent(txs, "", "  ")
-			} else {
-				output, err = cdc.MarshalJSON(txs)
-			}
-
-			if err != nil {
-				return err
-			}
-
-			fmt.Println(string(output))
-			return nil
-		},
-	}
-
-	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
-	viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
-	cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
-	viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
-	cmd.Flags().String(flagTags, "", "tag:value list of tags that must match")
-	cmd.Flags().Int32(flagPage, defaultPage, "Query a specific page of paginated results")
-	cmd.Flags().Int32(flagLimit, defaultLimit, "Query number of transactions results per page returned")
-	cmd.MarkFlagRequired(flagTags)
-	return cmd
-}
-
-// SearchTxs performs a search for transactions for a given set of tags via
-// Tendermint RPC. It returns a slice of Info object containing txs and metadata.
-// An error is returned if the query fails.
-func SearchTxs(cliCtx context.CLIContext, cdc *codec.Codec, tags []string, page, limit int) ([]sdk.TxResponse, error) {
-	if len(tags) == 0 {
-		return nil, errors.New("must declare at least one tag to search")
-	}
-
-	if page <= 0 {
-		return nil, errors.New("page must greater than 0")
-	}
-
-	if limit <= 0 {
-		return nil, errors.New("limit must greater than 0")
-	}
-
-	// XXX: implement ANY
-	query := strings.Join(tags, " AND ")
-
-	// get the node
-	node, err := cliCtx.GetNode()
-	if err != nil {
-		return nil, err
-	}
-
-	prove := !cliCtx.TrustNode
-
-	res, err := node.TxSearch(query, prove, page, limit)
-	if err != nil {
-		return nil, err
-	}
-
-	if prove {
-		for _, tx := range res.Txs {
-			err := ValidateTxResult(cliCtx, tx)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	info, err := FormatTxResults(cdc, res.Txs)
-	if err != nil {
-		return nil, err
-	}
-
-	return info, nil
-}
-
-// parse the indexed txs into an array of Info
-func FormatTxResults(cdc *codec.Codec, res []*ctypes.ResultTx) ([]sdk.TxResponse, error) {
-	var err error
-	out := make([]sdk.TxResponse, len(res))
-	for i := range res {
-		out[i], err = formatTxResult(cdc, res[i])
-		if err != nil {
-			return nil, err
-		}
-	}
-	return out, nil
-}
-
-/////////////////////////////////////////
-// REST
-
-// Search Tx REST Handler
-func SearchTxRequestHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var tags []string
-		var page, limit int
-		var txs []sdk.TxResponse
-		err := r.ParseForm()
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusBadRequest,
-				sdk.AppendMsgToErr("could not parse query parameters", err.Error()))
-			return
-		}
-		if len(r.Form) == 0 {
-			rest.PostProcessResponse(w, cdc, txs, cliCtx.Indent)
-			return
-		}
-
-		tags, page, limit, err = parseHTTPArgs(r)
-
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
-			return
-		}
-
-		txs, err = SearchTxs(cliCtx, cdc, tags, page, limit)
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
-			return
-		}
-
-		rest.PostProcessResponse(w, cdc, txs, cliCtx.Indent)
-	}
-}
-
-func parseHTTPArgs(r *http.Request) (tags []string, page, limit int, err error) {
-	tags = make([]string, 0, len(r.Form))
-	for key, values := range r.Form {
-		if key == "page" || key == "limit" {
-			continue
-		}
-		var value string
-		value, err = url.QueryUnescape(values[0])
-		if err != nil {
-			return tags, page, limit, err
-		}
-
-		var tag string
-		if key == types.TxHeightKey {
-			tag = fmt.Sprintf("%s=%s", key, value)
-		} else {
-			tag = fmt.Sprintf("%s='%s'", key, value)
-		}
-		tags = append(tags, tag)
-	}
-
-	pageStr := r.FormValue("page")
-	if pageStr == "" {
-		page = defaultPage
-	} else {
-		page, err = strconv.Atoi(pageStr)
-		if err != nil {
-			return tags, page, limit, err
-		} else if page <= 0 {
-			return tags, page, limit, errors.New("page must greater than 0")
-		}
-	}
-
-	limitStr := r.FormValue("limit")
-	if limitStr == "" {
-		limit = defaultLimit
-	} else {
-		limit, err = strconv.Atoi(limitStr)
-		if err != nil {
-			return tags, page, limit, err
-		} else if limit <= 0 {
-			return tags, page, limit, errors.New("limit must greater than 0")
-		}
-	}
-
-	return tags, page, limit, nil
-}
diff --git a/client/tx/utils.go b/client/tx/utils.go
new file mode 100644
index 000000000..41dfd72e8
--- /dev/null
+++ b/client/tx/utils.go
@@ -0,0 +1,173 @@
+package tx
+
+import (
+	"encoding/hex"
+	"errors"
+	"strings"
+	"time"
+
+	"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"
+	ctypes "github.com/tendermint/tendermint/rpc/core/types"
+)
+
+// SearchTxs performs a search for transactions for a given set of tags via
+// Tendermint RPC. It returns a slice of Info object containing txs and metadata.
+// An error is returned if the query fails.
+func SearchTxs(cliCtx context.CLIContext, cdc *codec.Codec, tags []string, page, limit int) ([]sdk.TxResponse, error) {
+	if len(tags) == 0 {
+		return nil, errors.New("must declare at least one tag to search")
+	}
+
+	if page <= 0 {
+		return nil, errors.New("page must greater than 0")
+	}
+
+	if limit <= 0 {
+		return nil, errors.New("limit must greater than 0")
+	}
+
+	// XXX: implement ANY
+	query := strings.Join(tags, " AND ")
+
+	node, err := cliCtx.GetNode()
+	if err != nil {
+		return nil, err
+	}
+
+	prove := !cliCtx.TrustNode
+
+	resTxs, err := node.TxSearch(query, prove, page, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	if prove {
+		for _, tx := range resTxs.Txs {
+			err := ValidateTxResult(cliCtx, tx)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	resBlocks, err := getBlocksForTxResults(cliCtx, resTxs.Txs)
+	if err != nil {
+		return nil, err
+	}
+
+	txs, err := formatTxResults(cdc, resTxs.Txs, resBlocks)
+	if err != nil {
+		return nil, err
+	}
+
+	return txs, nil
+}
+
+// formatTxResults parses the indexed txs into a slice of TxResponse objects.
+func formatTxResults(cdc *codec.Codec, resTxs []*ctypes.ResultTx, resBlocks map[int64]*ctypes.ResultBlock) ([]sdk.TxResponse, error) {
+	var err error
+	out := make([]sdk.TxResponse, len(resTxs))
+	for i := range resTxs {
+		out[i], err = formatTxResult(cdc, resTxs[i], resBlocks[resTxs[i].Height])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return out, nil
+}
+
+// ValidateTxResult performs transaction verification.
+func ValidateTxResult(cliCtx context.CLIContext, resTx *ctypes.ResultTx) error {
+	if !cliCtx.TrustNode {
+		check, err := cliCtx.Verify(resTx.Height)
+		if err != nil {
+			return err
+		}
+		err = resTx.Proof.Validate(check.Header.DataHash)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func getBlocksForTxResults(cliCtx context.CLIContext, resTxs []*ctypes.ResultTx) (map[int64]*ctypes.ResultBlock, error) {
+	node, err := cliCtx.GetNode()
+	if err != nil {
+		return nil, err
+	}
+
+	resBlocks := make(map[int64]*ctypes.ResultBlock)
+
+	for _, resTx := range resTxs {
+		if _, ok := resBlocks[resTx.Height]; !ok {
+			resBlock, err := node.Block(&resTx.Height)
+			if err != nil {
+				return nil, err
+			}
+
+			resBlocks[resTx.Height] = resBlock
+		}
+	}
+
+	return resBlocks, nil
+}
+
+func formatTxResult(cdc *codec.Codec, resTx *ctypes.ResultTx, resBlock *ctypes.ResultBlock) (sdk.TxResponse, error) {
+	tx, err := parseTx(cdc, resTx.Tx)
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	return sdk.NewResponseResultTx(resTx, tx, resBlock.Block.Time.Format(time.RFC3339)), nil
+}
+
+func parseTx(cdc *codec.Codec, txBytes []byte) (sdk.Tx, error) {
+	var tx auth.StdTx
+
+	err := cdc.UnmarshalBinaryLengthPrefixed(txBytes, &tx)
+	if err != nil {
+		return nil, err
+	}
+
+	return tx, nil
+}
+
+func queryTx(cdc *codec.Codec, cliCtx context.CLIContext, hashHexStr string) (sdk.TxResponse, error) {
+	hash, err := hex.DecodeString(hashHexStr)
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	node, err := cliCtx.GetNode()
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	resTx, err := node.Tx(hash, !cliCtx.TrustNode)
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	if !cliCtx.TrustNode {
+		if err = ValidateTxResult(cliCtx, resTx); err != nil {
+			return sdk.TxResponse{}, err
+		}
+	}
+
+	resBlocks, err := getBlocksForTxResults(cliCtx, []*ctypes.ResultTx{resTx})
+	if err != nil {
+		return sdk.TxResponse{}, err
+	}
+
+	out, err := formatTxResult(cdc, resTx, resBlocks[resTx.Height])
+	if err != nil {
+		return out, err
+	}
+
+	return out, nil
+}
diff --git a/client/utils/utils.go b/client/utils/utils.go
index 8d1c0b494..25d81c451 100644
--- a/client/utils/utils.go
+++ b/client/utils/utils.go
@@ -6,6 +6,8 @@ import (
 	"io/ioutil"
 	"os"
 
+	"github.com/spf13/viper"
+
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/codec"
 
@@ -69,7 +71,17 @@ func CompleteAndBroadcastTxCLI(txBldr authtxb.TxBuilder, cliCtx context.CLIConte
 			return err
 		}
 
-		fmt.Fprintf(os.Stderr, "%s\n\n", cliCtx.Codec.MustMarshalJSON(stdSignMsg))
+		var json []byte
+		if viper.GetBool(client.FlagIndentResponse) {
+			json, err = cliCtx.Codec.MarshalJSONIndent(stdSignMsg, "", "  ")
+			if err != nil {
+				panic(err)
+			}
+		} else {
+			json = cliCtx.Codec.MustMarshalJSON(stdSignMsg)
+		}
+
+		fmt.Fprintf(os.Stderr, "%s\n\n", json)
 
 		buf := client.BufferStdin()
 		ok, err := client.GetConfirmation("confirm transaction before signing and broadcasting", buf)
@@ -92,8 +104,11 @@ func CompleteAndBroadcastTxCLI(txBldr authtxb.TxBuilder, cliCtx context.CLIConte
 
 	// broadcast to a Tendermint node
 	res, err := cliCtx.BroadcastTx(txBytes)
-	cliCtx.PrintOutput(res)
-	return err
+	if err != nil {
+		return err
+	}
+
+	return cliCtx.PrintOutput(res)
 }
 
 // EnrichWithGas calculates the gas estimate that would be consumed by the
@@ -108,7 +123,9 @@ func EnrichWithGas(txBldr authtxb.TxBuilder, cliCtx context.CLIContext, msgs []s
 
 // CalculateGas simulates the execution of a transaction and returns
 // both the estimate obtained by the query and the adjusted amount.
-func CalculateGas(queryFunc func(string, common.HexBytes) ([]byte, error), cdc *amino.Codec, txBytes []byte, adjustment float64) (estimate, adjusted uint64, err error) {
+func CalculateGas(queryFunc func(string, common.HexBytes) ([]byte, error),
+	cdc *amino.Codec, txBytes []byte, adjustment float64) (estimate, adjusted uint64, err error) {
+
 	// run a simulation (via /app/simulate query) to
 	// estimate gas and update TxBuilder accordingly
 	rawRes, err := queryFunc("/app/simulate", txBytes)
@@ -149,15 +166,17 @@ func PrintUnsignedStdTx(
 	return
 }
 
-// SignStdTx appends a signature to a StdTx and returns a copy of a it. If appendSig
+// SignStdTx appends a signature to a StdTx and returns a copy of it. If appendSig
 // is false, it replaces the signatures already attached with the new signature.
 // Don't perform online validation or lookups if offline is true.
-func SignStdTx(txBldr authtxb.TxBuilder, cliCtx context.CLIContext, name string, stdTx auth.StdTx, appendSig bool, offline bool) (auth.StdTx, error) {
+func SignStdTx(
+	txBldr authtxb.TxBuilder, cliCtx context.CLIContext, name string,
+	stdTx auth.StdTx, appendSig bool, offline bool,
+) (auth.StdTx, error) {
+
 	var signedStdTx auth.StdTx
 
-	keybase := txBldr.Keybase()
-
-	info, err := keybase.Get(name)
+	info, err := txBldr.Keybase().Get(name)
 	if err != nil {
 		return signedStdTx, err
 	}
@@ -170,8 +189,7 @@ func SignStdTx(txBldr authtxb.TxBuilder, cliCtx context.CLIContext, name string,
 	}
 
 	if !offline {
-		txBldr, err = populateAccountFromState(
-			txBldr, cliCtx, sdk.AccAddress(addr))
+		txBldr, err = populateAccountFromState(txBldr, cliCtx, sdk.AccAddress(addr))
 		if err != nil {
 			return signedStdTx, err
 		}
@@ -229,25 +247,21 @@ func ReadStdTxFromFile(cdc *amino.Codec, filename string) (stdTx auth.StdTx, err
 	return
 }
 
-func populateAccountFromState(txBldr authtxb.TxBuilder, cliCtx context.CLIContext,
-	addr sdk.AccAddress) (authtxb.TxBuilder, error) {
-	if txBldr.AccountNumber() == 0 {
-		accNum, err := cliCtx.GetAccountNumber(addr)
-		if err != nil {
-			return txBldr, err
-		}
-		txBldr = txBldr.WithAccountNumber(accNum)
+func populateAccountFromState(
+	txBldr authtxb.TxBuilder, cliCtx context.CLIContext, addr sdk.AccAddress,
+) (authtxb.TxBuilder, error) {
+
+	accNum, err := cliCtx.GetAccountNumber(addr)
+	if err != nil {
+		return txBldr, err
 	}
 
-	if txBldr.Sequence() == 0 {
-		accSeq, err := cliCtx.GetAccountSequence(addr)
-		if err != nil {
-			return txBldr, err
-		}
-		txBldr = txBldr.WithSequence(accSeq)
+	accSeq, err := cliCtx.GetAccountSequence(addr)
+	if err != nil {
+		return txBldr, err
 	}
 
-	return txBldr, nil
+	return txBldr.WithAccountNumber(accNum).WithSequence(accSeq), nil
 }
 
 // GetTxEncoder return tx encoder from global sdk configuration if ones is defined.
diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go
index 36044513f..262115649 100644
--- a/cmd/gaia/app/app.go
+++ b/cmd/gaia/app/app.go
@@ -11,14 +11,12 @@ import (
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"
 
-	// TODO: Remove once transfers are enabled.
-	gaiabank "github.com/cosmos/cosmos-sdk/cmd/gaia/app/x/bank"
-
 	bam "github.com/cosmos/cosmos-sdk/baseapp"
 	"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/bank"
+	"github.com/cosmos/cosmos-sdk/x/crisis"
 	distr "github.com/cosmos/cosmos-sdk/x/distribution"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/mint"
@@ -44,6 +42,8 @@ type GaiaApp struct {
 	*bam.BaseApp
 	cdc *codec.Codec
 
+	assertInvariantsBlockly bool
+
 	// keys to access the substores
 	keyMain          *sdk.KVStoreKey
 	keyAccount       *sdk.KVStoreKey
@@ -67,11 +67,14 @@ type GaiaApp struct {
 	mintKeeper          mint.Keeper
 	distrKeeper         distr.Keeper
 	govKeeper           gov.Keeper
+	crisisKeeper        crisis.Keeper
 	paramsKeeper        params.Keeper
 }
 
 // NewGaiaApp returns a reference to an initialized GaiaApp.
-func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bool, baseAppOptions ...func(*bam.BaseApp)) *GaiaApp {
+func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest, assertInvariantsBlockly bool,
+	baseAppOptions ...func(*bam.BaseApp)) *GaiaApp {
+
 	cdc := MakeCodec()
 
 	bApp := bam.NewBaseApp(appName, logger, db, auth.DefaultTxDecoder(cdc), baseAppOptions...)
@@ -143,6 +146,12 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest b
 		app.paramsKeeper, app.paramsKeeper.Subspace(gov.DefaultParamspace), app.bankKeeper, &stakingKeeper,
 		gov.DefaultCodespace,
 	)
+	app.crisisKeeper = crisis.NewKeeper(
+		app.paramsKeeper.Subspace(crisis.DefaultParamspace),
+		app.distrKeeper,
+		app.bankKeeper,
+		app.feeCollectionKeeper,
+	)
 
 	// register the staking hooks
 	// NOTE: The stakingKeeper above is passed by reference, so that it can be
@@ -151,22 +160,27 @@ func NewGaiaApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest b
 		NewStakingHooks(app.distrKeeper.Hooks(), app.slashingKeeper.Hooks()),
 	)
 
+	// register the crisis routes
+	bank.RegisterInvariants(&app.crisisKeeper, app.accountKeeper)
+	distr.RegisterInvariants(&app.crisisKeeper, app.distrKeeper, app.stakingKeeper)
+	staking.RegisterInvariants(&app.crisisKeeper, app.stakingKeeper, app.feeCollectionKeeper, app.distrKeeper, app.accountKeeper)
+
 	// register message routes
-	//
-	// TODO: Use standard bank router once transfers are enabled.
 	app.Router().
-		AddRoute(bank.RouterKey, gaiabank.NewHandler(app.bankKeeper)).
+		AddRoute(bank.RouterKey, bank.NewHandler(app.bankKeeper)).
 		AddRoute(staking.RouterKey, staking.NewHandler(app.stakingKeeper)).
 		AddRoute(distr.RouterKey, distr.NewHandler(app.distrKeeper)).
 		AddRoute(slashing.RouterKey, slashing.NewHandler(app.slashingKeeper)).
-		AddRoute(gov.RouterKey, gov.NewHandler(app.govKeeper))
+		AddRoute(gov.RouterKey, gov.NewHandler(app.govKeeper)).
+		AddRoute(crisis.RouterKey, crisis.NewHandler(app.crisisKeeper))
 
 	app.QueryRouter().
 		AddRoute(auth.QuerierRoute, auth.NewQuerier(app.accountKeeper)).
 		AddRoute(distr.QuerierRoute, distr.NewQuerier(app.distrKeeper)).
 		AddRoute(gov.QuerierRoute, gov.NewQuerier(app.govKeeper)).
 		AddRoute(slashing.QuerierRoute, slashing.NewQuerier(app.slashingKeeper, app.cdc)).
-		AddRoute(staking.QuerierRoute, staking.NewQuerier(app.stakingKeeper, app.cdc))
+		AddRoute(staking.QuerierRoute, staking.NewQuerier(app.stakingKeeper, app.cdc)).
+		AddRoute(mint.QuerierRoute, mint.NewQuerier(app.mintKeeper))
 
 	// initialize BaseApp
 	app.MountStores(app.keyMain, app.keyAccount, app.keyStaking, app.keyMint, app.keyDistr,
@@ -197,6 +211,7 @@ func MakeCodec() *codec.Codec {
 	slashing.RegisterCodec(cdc)
 	gov.RegisterCodec(cdc)
 	auth.RegisterCodec(cdc)
+	crisis.RegisterCodec(cdc)
 	sdk.RegisterCodec(cdc)
 	codec.RegisterCrypto(cdc)
 	return cdc
@@ -229,7 +244,9 @@ func (app *GaiaApp) EndBlocker(ctx sdk.Context, req abci.RequestEndBlock) abci.R
 	validatorUpdates, endBlockerTags := staking.EndBlocker(ctx, app.stakingKeeper)
 	tags = append(tags, endBlockerTags...)
 
-	app.assertRuntimeInvariants()
+	if app.assertInvariantsBlockly {
+		app.assertRuntimeInvariants()
+	}
 
 	return abci.ResponseEndBlock{
 		ValidatorUpdates: validatorUpdates,
@@ -262,6 +279,7 @@ func (app *GaiaApp) initFromGenesisState(ctx sdk.Context, genesisState GenesisSt
 	bank.InitGenesis(ctx, app.bankKeeper, genesisState.BankData)
 	slashing.InitGenesis(ctx, app.slashingKeeper, genesisState.SlashingData, genesisState.StakingData.Validators.ToSDKValidators())
 	gov.InitGenesis(ctx, app.govKeeper, genesisState.GovData)
+	crisis.InitGenesis(ctx, app.crisisKeeper, genesisState.CrisisData)
 	mint.InitGenesis(ctx, app.mintKeeper, genesisState.MintData)
 
 	// validate genesis state
diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index 0ee1596ea..ec38f06a6 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/cosmos/cosmos-sdk/x/bank"
+	"github.com/cosmos/cosmos-sdk/x/crisis"
 
 	"github.com/stretchr/testify/require"
 	"github.com/tendermint/tendermint/libs/db"
@@ -35,6 +36,7 @@ func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
 		mint.DefaultGenesisState(),
 		distr.DefaultGenesisState(),
 		gov.DefaultGenesisState(),
+		crisis.DefaultGenesisState(),
 		slashing.DefaultGenesisState(),
 	)
 
@@ -53,11 +55,11 @@ func setGenesis(gapp *GaiaApp, accs ...*auth.BaseAccount) error {
 
 func TestGaiadExport(t *testing.T) {
 	db := db.NewMemDB()
-	gapp := NewGaiaApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true)
+	gapp := NewGaiaApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, false)
 	setGenesis(gapp)
 
 	// Making a new app object with the db, so that initchain hasn't been called
-	newGapp := NewGaiaApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true)
+	newGapp := NewGaiaApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, false)
 	_, _, err := newGapp.ExportAppStateAndValidators(false, []string{})
 	require.NoError(t, err, "ExportAppStateAndValidators should not have an error")
 }
diff --git a/cmd/gaia/app/export.go b/cmd/gaia/app/export.go
index 773a71838..5174c1498 100644
--- a/cmd/gaia/app/export.go
+++ b/cmd/gaia/app/export.go
@@ -11,6 +11,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
+	"github.com/cosmos/cosmos-sdk/x/crisis"
 	distr "github.com/cosmos/cosmos-sdk/x/distribution"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/mint"
@@ -46,6 +47,7 @@ func (app *GaiaApp) ExportAppStateAndValidators(forZeroHeight bool, jailWhiteLis
 		mint.ExportGenesis(ctx, app.mintKeeper),
 		distr.ExportGenesis(ctx, app.distrKeeper),
 		gov.ExportGenesis(ctx, app.govKeeper),
+		crisis.ExportGenesis(ctx, app.crisisKeeper),
 		slashing.ExportGenesis(ctx, app.slashingKeeper),
 	)
 	appState, err = codec.MarshalJSONIndent(app.cdc, genState)
diff --git a/cmd/gaia/app/genesis.go b/cmd/gaia/app/genesis.go
index 65a64033b..997cd131c 100644
--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@@ -17,6 +17,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
+	"github.com/cosmos/cosmos-sdk/x/crisis"
 	distr "github.com/cosmos/cosmos-sdk/x/distribution"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/mint"
@@ -39,6 +40,7 @@ type GenesisState struct {
 	MintData     mint.GenesisState     `json:"mint"`
 	DistrData    distr.GenesisState    `json:"distr"`
 	GovData      gov.GenesisState      `json:"gov"`
+	CrisisData   crisis.GenesisState   `json:"crisis"`
 	SlashingData slashing.GenesisState `json:"slashing"`
 	GenTxs       []json.RawMessage     `json:"gentxs"`
 }
@@ -46,7 +48,7 @@ type GenesisState struct {
 func NewGenesisState(accounts []GenesisAccount, authData auth.GenesisState,
 	bankData bank.GenesisState,
 	stakingData staking.GenesisState, mintData mint.GenesisState,
-	distrData distr.GenesisState, govData gov.GenesisState,
+	distrData distr.GenesisState, govData gov.GenesisState, crisisData crisis.GenesisState,
 	slashingData slashing.GenesisState) GenesisState {
 
 	return GenesisState{
@@ -57,6 +59,7 @@ func NewGenesisState(accounts []GenesisAccount, authData auth.GenesisState,
 		MintData:     mintData,
 		DistrData:    distrData,
 		GovData:      govData,
+		CrisisData:   crisisData,
 		SlashingData: slashingData,
 	}
 }
@@ -209,6 +212,7 @@ func NewDefaultGenesisState() GenesisState {
 		MintData:     mint.DefaultGenesisState(),
 		DistrData:    distr.DefaultGenesisState(),
 		GovData:      gov.DefaultGenesisState(),
+		CrisisData:   crisis.DefaultGenesisState(),
 		SlashingData: slashing.DefaultGenesisState(),
 		GenTxs:       nil,
 	}
@@ -246,6 +250,9 @@ func GaiaValidateGenesisState(genesisState GenesisState) error {
 	if err := gov.ValidateGenesis(genesisState.GovData); err != nil {
 		return err
 	}
+	if err := crisis.ValidateGenesis(genesisState.CrisisData); err != nil {
+		return err
+	}
 
 	return slashing.ValidateGenesis(genesisState.SlashingData)
 }
diff --git a/cmd/gaia/app/genesis_test.go b/cmd/gaia/app/genesis_test.go
index 4d39b4e48..300f4afcd 100644
--- a/cmd/gaia/app/genesis_test.go
+++ b/cmd/gaia/app/genesis_test.go
@@ -41,7 +41,7 @@ func makeGenesisState(t *testing.T, genTxs []auth.StdTx) GenesisState {
 		msg := msgs[0].(staking.MsgCreateValidator)
 
 		acc := auth.NewBaseAccountWithAddress(sdk.AccAddress(msg.ValidatorAddress))
-		acc.Coins = sdk.Coins{sdk.NewInt64Coin(defaultBondDenom, 150)}
+		acc.Coins = sdk.NewCoins(sdk.NewInt64Coin(defaultBondDenom, 150))
 		genAccs[i] = NewGenesisAccount(&acc)
 		stakingData.Pool.NotBondedTokens = stakingData.Pool.NotBondedTokens.Add(sdk.NewInt(150)) // increase the supply
 	}
@@ -55,7 +55,7 @@ func TestToAccount(t *testing.T) {
 	priv := ed25519.GenPrivKey()
 	addr := sdk.AccAddress(priv.PubKey().Address())
 	authAcc := auth.NewBaseAccountWithAddress(addr)
-	authAcc.SetCoins(sdk.Coins{sdk.NewInt64Coin(defaultBondDenom, 150)})
+	authAcc.SetCoins(sdk.NewCoins(sdk.NewInt64Coin(defaultBondDenom, 150)))
 	genAcc := NewGenesisAccount(&authAcc)
 	acc := genAcc.ToAccount()
 	require.IsType(t, &auth.BaseAccount{}, acc)
diff --git a/cmd/gaia/app/invariants.go b/cmd/gaia/app/invariants.go
index 535cbff37..841732ca1 100644
--- a/cmd/gaia/app/invariants.go
+++ b/cmd/gaia/app/invariants.go
@@ -7,20 +7,8 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	banksim "github.com/cosmos/cosmos-sdk/x/bank/simulation"
-	distrsim "github.com/cosmos/cosmos-sdk/x/distribution/simulation"
-	stakingsim "github.com/cosmos/cosmos-sdk/x/staking/simulation"
 )
 
-func (app *GaiaApp) runtimeInvariants() []sdk.Invariant {
-	return []sdk.Invariant{
-		banksim.NonnegativeBalanceInvariant(app.accountKeeper),
-		distrsim.NonNegativeOutstandingInvariant(app.distrKeeper),
-		stakingsim.SupplyInvariants(app.stakingKeeper, app.feeCollectionKeeper, app.distrKeeper, app.accountKeeper),
-		stakingsim.NonNegativePowerInvariant(app.stakingKeeper),
-	}
-}
-
 func (app *GaiaApp) assertRuntimeInvariants() {
 	ctx := app.NewContext(false, abci.Header{Height: app.LastBlockHeight() + 1})
 	app.assertRuntimeInvariantsOnContext(ctx)
@@ -28,10 +16,12 @@ func (app *GaiaApp) assertRuntimeInvariants() {
 
 func (app *GaiaApp) assertRuntimeInvariantsOnContext(ctx sdk.Context) {
 	start := time.Now()
-	invariants := app.runtimeInvariants()
-	for _, inv := range invariants {
-		if err := inv(ctx); err != nil {
-			panic(fmt.Errorf("invariant broken: %s", err))
+	invarRoutes := app.crisisKeeper.Routes()
+	for _, ir := range invarRoutes {
+		if err := ir.Invar(ctx); err != nil {
+			panic(fmt.Errorf("invariant broken: %s\n"+
+				"\tCRITICAL please submit the following transaction:\n"+
+				"\t\t gaiacli tx crisis invariant-broken %v %v", err, ir.ModuleName, ir.Route))
 		}
 	}
 	end := time.Now()
diff --git a/cmd/gaia/app/sim_test.go b/cmd/gaia/app/sim_test.go
index 2cba35458..247cc262a 100644
--- a/cmd/gaia/app/sim_test.go
+++ b/cmd/gaia/app/sim_test.go
@@ -29,7 +29,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	govsim "github.com/cosmos/cosmos-sdk/x/gov/simulation"
 	"github.com/cosmos/cosmos-sdk/x/mint"
-	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
 	slashingsim "github.com/cosmos/cosmos-sdk/x/slashing/simulation"
 	"github.com/cosmos/cosmos-sdk/x/staking"
@@ -43,19 +43,30 @@ var (
 	blockSize   int
 	enabled     bool
 	verbose     bool
+	lean        bool
 	commit      bool
 	period      int
 )
 
 func init() {
-	flag.StringVar(&genesisFile, "SimulationGenesis", "", "Custom simulation genesis file")
-	flag.Int64Var(&seed, "SimulationSeed", 42, "Simulation random seed")
-	flag.IntVar(&numBlocks, "SimulationNumBlocks", 500, "Number of blocks")
-	flag.IntVar(&blockSize, "SimulationBlockSize", 200, "Operations per block")
-	flag.BoolVar(&enabled, "SimulationEnabled", false, "Enable the simulation")
-	flag.BoolVar(&verbose, "SimulationVerbose", false, "Verbose log output")
-	flag.BoolVar(&commit, "SimulationCommit", false, "Have the simulation commit")
-	flag.IntVar(&period, "SimulationPeriod", 1, "Run slow invariants only once every period assertions")
+	flag.StringVar(&genesisFile, "SimulationGenesis", "", "custom simulation genesis file")
+	flag.Int64Var(&seed, "SimulationSeed", 42, "simulation random seed")
+	flag.IntVar(&numBlocks, "SimulationNumBlocks", 500, "number of blocks")
+	flag.IntVar(&blockSize, "SimulationBlockSize", 200, "operations per block")
+	flag.BoolVar(&enabled, "SimulationEnabled", false, "enable the simulation")
+	flag.BoolVar(&verbose, "SimulationVerbose", false, "verbose log output")
+	flag.BoolVar(&lean, "SimulationLean", false, "lean simulation log output")
+	flag.BoolVar(&commit, "SimulationCommit", false, "have the simulation commit")
+	flag.IntVar(&period, "SimulationPeriod", 1, "run slow invariants only once every period assertions")
+}
+
+// helper function for populating input for SimulateFromSeed
+func getSimulateFromSeedInput(tb testing.TB, app *GaiaApp) (
+	testing.TB, *baseapp.BaseApp, simulation.AppStateFn, int64,
+	simulation.WeightedOperations, sdk.Invariants, int, int, bool, bool) {
+
+	return tb, app.BaseApp, appStateFn, seed,
+		testAndRunTxs(app), invariants(app), numBlocks, blockSize, commit, lean
 }
 
 func appStateFromGenesisFileFn(r *rand.Rand, accs []simulation.Account, genesisTimestamp time.Time) (json.RawMessage, []simulation.Account, string) {
@@ -92,7 +103,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
 		numInitiallyBonded = numAccs
 	}
 	fmt.Printf("Selected randomly generated parameters for simulated genesis:\n"+
-		"\t{amount of steak per account: %v, initially bonded validators: %v}\n",
+		"\t{amount of stake per account: %v, initially bonded validators: %v}\n",
 		amount, numInitiallyBonded)
 
 	// randomly generate some genesis accounts
@@ -265,8 +276,8 @@ func randIntBetween(r *rand.Rand, min, max int) int {
 func testAndRunTxs(app *GaiaApp) []simulation.WeightedOperation {
 	return []simulation.WeightedOperation{
 		{5, authsim.SimulateDeductFee(app.accountKeeper, app.feeCollectionKeeper)},
-		{100, banksim.SendMsg(app.accountKeeper, app.bankKeeper)},
-		{10, banksim.SingleInputMsgMultiSend(app.accountKeeper, app.bankKeeper)},
+		{100, banksim.SimulateMsgSend(app.accountKeeper, app.bankKeeper)},
+		{10, banksim.SimulateSingleInputMsgMultiSend(app.accountKeeper, app.bankKeeper)},
 		{50, distrsim.SimulateMsgSetWithdrawAddress(app.accountKeeper, app.distrKeeper)},
 		{50, distrsim.SimulateMsgWithdrawDelegatorReward(app.accountKeeper, app.distrKeeper)},
 		{50, distrsim.SimulateMsgWithdrawValidatorCommission(app.accountKeeper, app.distrKeeper)},
@@ -283,12 +294,10 @@ func testAndRunTxs(app *GaiaApp) []simulation.WeightedOperation {
 
 func invariants(app *GaiaApp) []sdk.Invariant {
 	return []sdk.Invariant{
-		simulation.PeriodicInvariant(banksim.NonnegativeBalanceInvariant(app.accountKeeper), period, 0),
-		simulation.PeriodicInvariant(govsim.AllInvariants(), period, 0),
-		simulation.PeriodicInvariant(distrsim.AllInvariants(app.distrKeeper, app.stakingKeeper), period, 0),
-		simulation.PeriodicInvariant(stakingsim.AllInvariants(app.stakingKeeper, app.feeCollectionKeeper,
+		simulation.PeriodicInvariant(bank.NonnegativeBalanceInvariant(app.accountKeeper), period, 0),
+		simulation.PeriodicInvariant(distr.AllInvariants(app.distrKeeper, app.stakingKeeper), period, 0),
+		simulation.PeriodicInvariant(staking.AllInvariants(app.stakingKeeper, app.feeCollectionKeeper,
 			app.distrKeeper, app.accountKeeper), period, 0),
-		simulation.PeriodicInvariant(slashingsim.AllInvariants(), period, 0),
 	}
 }
 
@@ -310,18 +319,11 @@ func BenchmarkFullGaiaSimulation(b *testing.B) {
 		db.Close()
 		os.RemoveAll(dir)
 	}()
-	app := NewGaiaApp(logger, db, nil, true)
+	app := NewGaiaApp(logger, db, nil, true, false)
 
 	// Run randomized simulation
 	// TODO parameterize numbers, save for a later PR
-	_, err := simulation.SimulateFromSeed(
-		b, app.BaseApp, appStateFn, seed,
-		testAndRunTxs(app),
-		invariants(app), // these shouldn't get ran
-		numBlocks,
-		blockSize,
-		commit,
-	)
+	_, err := simulation.SimulateFromSeed(getSimulateFromSeedInput(b, app))
 	if err != nil {
 		fmt.Println(err)
 		b.Fail()
@@ -352,18 +354,11 @@ func TestFullGaiaSimulation(t *testing.T) {
 		db.Close()
 		os.RemoveAll(dir)
 	}()
-	app := NewGaiaApp(logger, db, nil, true, fauxMerkleModeOpt)
+	app := NewGaiaApp(logger, db, nil, true, false, fauxMerkleModeOpt)
 	require.Equal(t, "GaiaApp", app.Name())
 
 	// Run randomized simulation
-	_, err := simulation.SimulateFromSeed(
-		t, app.BaseApp, appStateFn, seed,
-		testAndRunTxs(app),
-		invariants(app),
-		numBlocks,
-		blockSize,
-		commit,
-	)
+	_, err := simulation.SimulateFromSeed(getSimulateFromSeedInput(t, app))
 	if commit {
 		// for memdb:
 		// fmt.Println("Database Size", db.Stats()["database.size"])
@@ -393,18 +388,12 @@ func TestGaiaImportExport(t *testing.T) {
 		db.Close()
 		os.RemoveAll(dir)
 	}()
-	app := NewGaiaApp(logger, db, nil, true, fauxMerkleModeOpt)
+	app := NewGaiaApp(logger, db, nil, true, false, fauxMerkleModeOpt)
 	require.Equal(t, "GaiaApp", app.Name())
 
 	// Run randomized simulation
-	_, err := simulation.SimulateFromSeed(
-		t, app.BaseApp, appStateFn, seed,
-		testAndRunTxs(app),
-		invariants(app),
-		numBlocks,
-		blockSize,
-		commit,
-	)
+	_, err := simulation.SimulateFromSeed(getSimulateFromSeedInput(t, app))
+
 	if commit {
 		// for memdb:
 		// fmt.Println("Database Size", db.Stats()["database.size"])
@@ -426,7 +415,7 @@ func TestGaiaImportExport(t *testing.T) {
 		newDB.Close()
 		os.RemoveAll(newDir)
 	}()
-	newApp := NewGaiaApp(log.NewNopLogger(), newDB, nil, true, fauxMerkleModeOpt)
+	newApp := NewGaiaApp(log.NewNopLogger(), newDB, nil, true, false, fauxMerkleModeOpt)
 	require.Equal(t, "GaiaApp", newApp.Name())
 	var genesisState GenesisState
 	err = app.cdc.UnmarshalJSON(appState, &genesisState)
@@ -446,7 +435,8 @@ func TestGaiaImportExport(t *testing.T) {
 	storeKeysPrefixes := []StoreKeysPrefixes{
 		{app.keyMain, newApp.keyMain, [][]byte{}},
 		{app.keyAccount, newApp.keyAccount, [][]byte{}},
-		{app.keyStaking, newApp.keyStaking, [][]byte{staking.UnbondingQueueKey, staking.RedelegationQueueKey, staking.ValidatorQueueKey}}, // ordering may change but it doesn't matter
+		{app.keyStaking, newApp.keyStaking, [][]byte{staking.UnbondingQueueKey,
+			staking.RedelegationQueueKey, staking.ValidatorQueueKey}}, // ordering may change but it doesn't matter
 		{app.keySlashing, newApp.keySlashing, [][]byte{}},
 		{app.keyMint, newApp.keyMint, [][]byte{}},
 		{app.keyDistr, newApp.keyDistr, [][]byte{}},
@@ -488,18 +478,12 @@ func TestGaiaSimulationAfterImport(t *testing.T) {
 		db.Close()
 		os.RemoveAll(dir)
 	}()
-	app := NewGaiaApp(logger, db, nil, true, fauxMerkleModeOpt)
+	app := NewGaiaApp(logger, db, nil, true, false, fauxMerkleModeOpt)
 	require.Equal(t, "GaiaApp", app.Name())
 
 	// Run randomized simulation
-	stopEarly, err := simulation.SimulateFromSeed(
-		t, app.BaseApp, appStateFn, seed,
-		testAndRunTxs(app),
-		invariants(app),
-		numBlocks,
-		blockSize,
-		commit,
-	)
+	stopEarly, err := simulation.SimulateFromSeed(getSimulateFromSeedInput(t, app))
+
 	if commit {
 		// for memdb:
 		// fmt.Println("Database Size", db.Stats()["database.size"])
@@ -530,21 +514,14 @@ func TestGaiaSimulationAfterImport(t *testing.T) {
 		newDB.Close()
 		os.RemoveAll(newDir)
 	}()
-	newApp := NewGaiaApp(log.NewNopLogger(), newDB, nil, true, fauxMerkleModeOpt)
+	newApp := NewGaiaApp(log.NewNopLogger(), newDB, nil, true, false, fauxMerkleModeOpt)
 	require.Equal(t, "GaiaApp", newApp.Name())
 	newApp.InitChain(abci.RequestInitChain{
 		AppStateBytes: appState,
 	})
 
 	// Run randomized simulation on imported app
-	_, err = simulation.SimulateFromSeed(
-		t, newApp.BaseApp, appStateFn, seed,
-		testAndRunTxs(newApp),
-		invariants(newApp),
-		numBlocks,
-		blockSize,
-		commit,
-	)
+	_, err = simulation.SimulateFromSeed(getSimulateFromSeedInput(t, newApp))
 	require.Nil(t, err)
 
 }
@@ -565,7 +542,7 @@ func TestAppStateDeterminism(t *testing.T) {
 		for j := 0; j < numTimesToRunPerSeed; j++ {
 			logger := log.NewNopLogger()
 			db := dbm.NewMemDB()
-			app := NewGaiaApp(logger, db, nil, true)
+			app := NewGaiaApp(logger, db, nil, true, false)
 
 			// Run randomized simulation
 			simulation.SimulateFromSeed(
@@ -575,6 +552,7 @@ func TestAppStateDeterminism(t *testing.T) {
 				50,
 				100,
 				true,
+				false,
 			)
 			appHash := app.LastCommitID().Hash
 			appHashList[j] = appHash
diff --git a/cmd/gaia/app/x/bank/handler.go b/cmd/gaia/app/x/bank/handler.go
deleted file mode 100644
index d3aa3415d..000000000
--- a/cmd/gaia/app/x/bank/handler.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Package bank contains a forked version of the bank module. It only contains
-// a modified message handler to support a very limited form of transfers during
-// mainnet launch -- MsgMultiSend messages.
-//
-// NOTE: This fork should be removed entirely once transfers are enabled and
-// the Gaia router should be reset to using the original bank module handler.
-package bank
-
-import (
-	"github.com/tendermint/tendermint/crypto"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/bank"
-)
-
-var (
-	uatomDenom    = "uatom"
-	atomsToUatoms = int64(1000000)
-
-	// BurnedCoinsAccAddr represents the burn account address used for
-	// MsgMultiSend message during the period for which transfers are disabled.
-	// Its Bech32 address is cosmos1x4p90uuy63fqzsheamn48vq88q3eusykf0a69v.
-	BurnedCoinsAccAddr = sdk.AccAddress(crypto.AddressHash([]byte("bankBurnedCoins")))
-)
-
-// NewHandler returns a handler for "bank" type messages.
-func NewHandler(k bank.Keeper) sdk.Handler {
-	return func(ctx sdk.Context, msg sdk.Msg) sdk.Result {
-		switch msg := msg.(type) {
-		case bank.MsgSend:
-			return handleMsgSend(ctx, k, msg)
-
-		case bank.MsgMultiSend:
-			return handleMsgMultiSend(ctx, k, msg)
-
-		default:
-			errMsg := "Unrecognized bank Msg type: %s" + msg.Type()
-			return sdk.ErrUnknownRequest(errMsg).Result()
-		}
-	}
-}
-
-// handleMsgSend implements a MsgSend message handler. It operates no differently
-// than the standard bank module MsgSend message handler in that it transfers
-// an amount from one account to another under the condition of transfers being
-// enabled.
-func handleMsgSend(ctx sdk.Context, k bank.Keeper, msg bank.MsgSend) sdk.Result {
-	// No need to modify handleMsgSend as the forked module requires no changes,
-	// so we can just call the standard bank modules handleMsgSend since we know
-	// the message is of type MsgSend.
-	return bank.NewHandler(k)(ctx, msg)
-}
-
-// handleMsgMultiSend implements a modified forked version of a MsgMultiSend
-// message handler. If transfers are disabled, a modified version of MsgMultiSend
-// is allowed where there must be a single input and only two outputs. The first
-// of the two outputs must be to a specific burn address defined by
-// burnedCoinsAccAddr. In addition, the output amounts must be of 9atom and
-// 1uatom respectively.
-func handleMsgMultiSend(ctx sdk.Context, k bank.Keeper, msg bank.MsgMultiSend) sdk.Result {
-	// NOTE: totalIn == totalOut should already have been checked
-	if !k.GetSendEnabled(ctx) {
-		if !validateMultiSendTransfersDisabled(msg) {
-			return bank.ErrSendDisabled(k.Codespace()).Result()
-		}
-	}
-
-	tags, err := k.InputOutputCoins(ctx, msg.Inputs, msg.Outputs)
-	if err != nil {
-		return err.Result()
-	}
-
-	return sdk.Result{
-		Tags: tags,
-	}
-}
-
-func validateMultiSendTransfersDisabled(msg bank.MsgMultiSend) bool {
-	nineAtoms := sdk.Coins{sdk.NewInt64Coin(uatomDenom, 9*atomsToUatoms)}
-	oneAtom := sdk.Coins{sdk.NewInt64Coin(uatomDenom, 1*atomsToUatoms)}
-
-	if len(msg.Inputs) != 1 {
-		return false
-	}
-	if len(msg.Outputs) != 2 {
-		return false
-	}
-
-	if !msg.Outputs[0].Address.Equals(BurnedCoinsAccAddr) {
-		return false
-	}
-	if !msg.Outputs[0].Coins.IsEqual(nineAtoms) {
-		return false
-	}
-	if !msg.Outputs[1].Coins.IsEqual(oneAtom) {
-		return false
-	}
-
-	return true
-}
diff --git a/cmd/gaia/app/x/bank/handler_test.go b/cmd/gaia/app/x/bank/handler_test.go
deleted file mode 100644
index c799e03f8..000000000
--- a/cmd/gaia/app/x/bank/handler_test.go
+++ /dev/null
@@ -1,216 +0,0 @@
-package bank
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto/secp256k1"
-	dbm "github.com/tendermint/tendermint/libs/db"
-	"github.com/tendermint/tendermint/libs/log"
-
-	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/cosmos/cosmos-sdk/store"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/auth"
-	"github.com/cosmos/cosmos-sdk/x/bank"
-	"github.com/cosmos/cosmos-sdk/x/params"
-)
-
-var (
-	addrs = []sdk.AccAddress{
-		sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address()),
-		sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address()),
-		sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address()),
-	}
-
-	initAmt = sdk.NewInt(atomsToUatoms * 100)
-)
-
-type testInput struct {
-	ctx        sdk.Context
-	accKeeper  auth.AccountKeeper
-	bankKeeper bank.Keeper
-}
-
-func newTestCodec() *codec.Codec {
-	cdc := codec.New()
-
-	bank.RegisterCodec(cdc)
-	auth.RegisterCodec(cdc)
-	sdk.RegisterCodec(cdc)
-	codec.RegisterCrypto(cdc)
-
-	return cdc
-}
-
-func createTestInput(t *testing.T) testInput {
-	keyAcc := sdk.NewKVStoreKey(auth.StoreKey)
-	keyParams := sdk.NewKVStoreKey(params.StoreKey)
-	tKeyParams := sdk.NewTransientStoreKey(params.TStoreKey)
-
-	cdc := newTestCodec()
-	db := dbm.NewMemDB()
-	ms := store.NewCommitMultiStore(db)
-	ctx := sdk.NewContext(ms, abci.Header{Time: time.Now().UTC()}, false, log.NewNopLogger())
-
-	ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(tKeyParams, sdk.StoreTypeTransient, db)
-	ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db)
-
-	require.NoError(t, ms.LoadLatestVersion())
-
-	paramsKeeper := params.NewKeeper(cdc, keyParams, tKeyParams)
-	accKeeper := auth.NewAccountKeeper(
-		cdc,
-		keyAcc,
-		paramsKeeper.Subspace(auth.DefaultParamspace),
-		auth.ProtoBaseAccount,
-	)
-
-	bankKeeper := bank.NewBaseKeeper(
-		accKeeper,
-		paramsKeeper.Subspace(bank.DefaultParamspace),
-		bank.DefaultCodespace,
-	)
-
-	for _, addr := range addrs {
-		_, _, err := bankKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewCoin(uatomDenom, initAmt)})
-		require.NoError(t, err)
-	}
-
-	return testInput{ctx, accKeeper, bankKeeper}
-}
-
-func TestHandlerMsgSendTransfersDisabled(t *testing.T) {
-	input := createTestInput(t)
-	input.bankKeeper.SetSendEnabled(input.ctx, false)
-
-	handler := NewHandler(input.bankKeeper)
-	amt := sdk.NewInt(atomsToUatoms * 5)
-	msg := bank.NewMsgSend(addrs[0], addrs[1], sdk.Coins{sdk.NewCoin(uatomDenom, amt)})
-
-	res := handler(input.ctx, msg)
-	require.False(t, res.IsOK(), "expected failed message execution: %v", res.Log)
-
-	from := input.accKeeper.GetAccount(input.ctx, addrs[0])
-	require.Equal(t, from.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, initAmt)})
-
-	to := input.accKeeper.GetAccount(input.ctx, addrs[1])
-	require.Equal(t, to.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, initAmt)})
-}
-
-func TestHandlerMsgSendTransfersEnabled(t *testing.T) {
-	input := createTestInput(t)
-	input.bankKeeper.SetSendEnabled(input.ctx, true)
-
-	handler := NewHandler(input.bankKeeper)
-	amt := sdk.NewInt(atomsToUatoms * 5)
-	msg := bank.NewMsgSend(addrs[0], addrs[1], sdk.Coins{sdk.NewCoin(uatomDenom, amt)})
-
-	res := handler(input.ctx, msg)
-	require.True(t, res.IsOK(), "expected successful message execution: %v", res.Log)
-
-	from := input.accKeeper.GetAccount(input.ctx, addrs[0])
-	balance := initAmt.Sub(amt)
-	require.Equal(t, from.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, balance)})
-
-	to := input.accKeeper.GetAccount(input.ctx, addrs[1])
-	balance = initAmt.Add(amt)
-	require.Equal(t, to.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, balance)})
-}
-
-func TestHandlerMsgMultiSendTransfersDisabledBurn(t *testing.T) {
-	input := createTestInput(t)
-	input.bankKeeper.SetSendEnabled(input.ctx, false)
-
-	handler := NewHandler(input.bankKeeper)
-	totalAmt := sdk.NewInt(10 * atomsToUatoms)
-	burnAmt := sdk.NewInt(9 * atomsToUatoms)
-	transAmt := sdk.NewInt(1 * atomsToUatoms)
-	msg := bank.NewMsgMultiSend(
-		[]bank.Input{
-			bank.NewInput(addrs[0], sdk.Coins{sdk.NewCoin(uatomDenom, totalAmt)}),
-		},
-		[]bank.Output{
-			bank.NewOutput(BurnedCoinsAccAddr, sdk.Coins{sdk.NewCoin(uatomDenom, burnAmt)}),
-			bank.NewOutput(addrs[1], sdk.Coins{sdk.NewCoin(uatomDenom, transAmt)}),
-		},
-	)
-
-	res := handler(input.ctx, msg)
-	require.True(t, res.IsOK(), "expected successful message execution: %v", res.Log)
-
-	from := input.accKeeper.GetAccount(input.ctx, addrs[0])
-	balance := initAmt.Sub(totalAmt)
-	require.Equal(t, from.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, balance)})
-
-	to := input.accKeeper.GetAccount(input.ctx, addrs[1])
-	balance = initAmt.Add(transAmt)
-	require.Equal(t, to.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, balance)})
-
-	burn := input.accKeeper.GetAccount(input.ctx, BurnedCoinsAccAddr)
-	require.Equal(t, burn.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, burnAmt)})
-}
-
-func TestHandlerMsgMultiSendTransfersDisabledInvalidBurn(t *testing.T) {
-	input := createTestInput(t)
-	input.bankKeeper.SetSendEnabled(input.ctx, false)
-
-	handler := NewHandler(input.bankKeeper)
-	totalAmt := sdk.NewInt(15 * atomsToUatoms)
-	burnAmt := sdk.NewInt(10 * atomsToUatoms)
-	transAmt := sdk.NewInt(5 * atomsToUatoms)
-	msg := bank.NewMsgMultiSend(
-		[]bank.Input{
-			bank.NewInput(addrs[0], sdk.Coins{sdk.NewCoin(uatomDenom, totalAmt)}),
-		},
-		[]bank.Output{
-			bank.NewOutput(BurnedCoinsAccAddr, sdk.Coins{sdk.NewCoin(uatomDenom, burnAmt)}),
-			bank.NewOutput(addrs[1], sdk.Coins{sdk.NewCoin(uatomDenom, transAmt)}),
-		},
-	)
-
-	res := handler(input.ctx, msg)
-	require.False(t, res.IsOK(), "expected failed message execution: %v", res.Log)
-
-	from := input.accKeeper.GetAccount(input.ctx, addrs[0])
-	require.Equal(t, from.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, initAmt)})
-
-	to := input.accKeeper.GetAccount(input.ctx, addrs[1])
-	require.Equal(t, to.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, initAmt)})
-}
-
-func TestHandlerMsgMultiSendTransfersEnabled(t *testing.T) {
-	input := createTestInput(t)
-	input.bankKeeper.SetSendEnabled(input.ctx, true)
-
-	handler := NewHandler(input.bankKeeper)
-	totalAmt := sdk.NewInt(10 * atomsToUatoms)
-	outAmt := sdk.NewInt(5 * atomsToUatoms)
-	msg := bank.NewMsgMultiSend(
-		[]bank.Input{
-			bank.NewInput(addrs[0], sdk.Coins{sdk.NewCoin(uatomDenom, totalAmt)}),
-		},
-		[]bank.Output{
-			bank.NewOutput(addrs[1], sdk.Coins{sdk.NewCoin(uatomDenom, outAmt)}),
-			bank.NewOutput(addrs[2], sdk.Coins{sdk.NewCoin(uatomDenom, outAmt)}),
-		},
-	)
-
-	res := handler(input.ctx, msg)
-	require.True(t, res.IsOK(), "expected successful message execution: %v", res.Log)
-
-	from := input.accKeeper.GetAccount(input.ctx, addrs[0])
-	balance := initAmt.Sub(totalAmt)
-	require.Equal(t, from.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, balance)})
-
-	out1 := input.accKeeper.GetAccount(input.ctx, addrs[1])
-	balance = initAmt.Add(outAmt)
-	require.Equal(t, out1.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, balance)})
-
-	out2 := input.accKeeper.GetAccount(input.ctx, addrs[2])
-	balance = initAmt.Add(outAmt)
-	require.Equal(t, out2.GetCoins(), sdk.Coins{sdk.NewCoin(uatomDenom, balance)})
-}
diff --git a/cmd/gaia/cli_test/cli_test.go b/cmd/gaia/cli_test/cli_test.go
index 3b4784fe2..b71d6c1c2 100644
--- a/cmd/gaia/cli_test/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@@ -1,3 +1,5 @@
+// +build cli_test
+
 package clitest
 
 import (
@@ -361,7 +363,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 	require.Equal(t, sendTokens, barAcc.GetCoins().AmountOf(denom))
 
 	// Generate a create validator transaction and ensure correctness
-	success, stdout, stderr := f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewInt64Coin(denom, 2), "--generate-only")
+	success, stdout, stderr := f.TxStakingCreateValidator(barAddr.String(), consPubKey, sdk.NewInt64Coin(denom, 2), "--generate-only")
 
 	require.True(f.T, success)
 	require.Empty(f.T, stderr)
@@ -394,13 +396,13 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 	require.NotZero(t, validatorDelegations[0].Shares)
 
 	// unbond a single share
-	unbondTokens := sdk.TokensFromTendermintPower(1)
-	success = f.TxStakingUnbond(keyBar, unbondTokens.String(), barVal, "-y")
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(1))
+	success = f.TxStakingUnbond(keyBar, unbondAmt.String(), barVal, "-y")
 	require.True(t, success)
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Ensure bonded staking is correct
-	remainingTokens := newValTokens.Sub(unbondTokens)
+	remainingTokens := newValTokens.Sub(unbondAmt.Amount)
 	validator = f.QueryStakingValidator(barVal)
 	require.Equal(t, remainingTokens, validator.Tokens)
 
@@ -437,7 +439,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	// Test submit generate only for submit proposal
 	proposalTokens := sdk.TokensFromTendermintPower(5)
 	success, stdout, stderr := f.TxGovSubmitProposal(
-		keyFoo, "Text", "Test", "test", sdk.NewCoin(denom, proposalTokens), "--generate-only", "-y")
+		fooAddr.String(), "Text", "Test", "test", sdk.NewCoin(denom, proposalTokens), "--generate-only", "-y")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg := unmarshalStdTx(t, stdout)
@@ -463,12 +465,12 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 
 	// Ensure propsal is directly queryable
 	proposal1 := f.QueryGovProposal(1)
-	require.Equal(t, uint64(1), proposal1.GetProposalID())
-	require.Equal(t, gov.StatusDepositPeriod, proposal1.GetStatus())
+	require.Equal(t, uint64(1), proposal1.ProposalID)
+	require.Equal(t, gov.StatusDepositPeriod, proposal1.Status)
 
 	// Ensure query proposals returns properly
 	proposalsQuery = f.QueryGovProposals()
-	require.Equal(t, uint64(1), proposalsQuery[0].GetProposalID())
+	require.Equal(t, uint64(1), proposalsQuery[0].ProposalID)
 
 	// Query the deposits on the proposal
 	deposit := f.QueryGovDeposit(1, fooAddr)
@@ -476,7 +478,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 
 	// Test deposit generate only
 	depositTokens := sdk.TokensFromTendermintPower(10)
-	success, stdout, stderr = f.TxGovDeposit(1, keyFoo, sdk.NewCoin(denom, depositTokens), "--generate-only")
+	success, stdout, stderr = f.TxGovDeposit(1, fooAddr.String(), sdk.NewCoin(denom, depositTokens), "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg = unmarshalStdTx(t, stdout)
@@ -507,11 +509,11 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 
 	// Fetch the proposal and ensure it is now in the voting period
 	proposal1 = f.QueryGovProposal(1)
-	require.Equal(t, uint64(1), proposal1.GetProposalID())
-	require.Equal(t, gov.StatusVotingPeriod, proposal1.GetStatus())
+	require.Equal(t, uint64(1), proposal1.ProposalID)
+	require.Equal(t, gov.StatusVotingPeriod, proposal1.Status)
 
 	// Test vote generate only
-	success, stdout, stderr = f.TxGovVote(1, gov.OptionYes, keyFoo, "--generate-only")
+	success, stdout, stderr = f.TxGovVote(1, gov.OptionYes, fooAddr.String(), "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg = unmarshalStdTx(t, stdout)
@@ -544,7 +546,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 
 	// Ensure the proposal returns as in the voting period
 	proposalsQuery = f.QueryGovProposals("--status=VotingPeriod")
-	require.Equal(t, uint64(1), proposalsQuery[0].GetProposalID())
+	require.Equal(t, uint64(1), proposalsQuery[0].ProposalID)
 
 	// submit a second test proposal
 	f.TxGovSubmitProposal(keyFoo, "Text", "Apples", "test", sdk.NewCoin(denom, proposalTokens), "-y")
@@ -552,7 +554,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 
 	// Test limit on proposals query
 	proposalsQuery = f.QueryGovProposals("--limit=1")
-	require.Equal(t, uint64(2), proposalsQuery[0].GetProposalID())
+	require.Equal(t, uint64(2), proposalsQuery[0].ProposalID)
 
 	f.Cleanup()
 }
@@ -618,7 +620,7 @@ func TestGaiaCLIValidateSignatures(t *testing.T) {
 	barAddr := f.KeyAddress(keyBar)
 
 	// generate sendTx with default gas
-	success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--generate-only")
+	success, stdout, stderr := f.TxSend(fooAddr.String(), barAddr, sdk.NewInt64Coin(denom, 10), "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 
@@ -669,7 +671,7 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 
 	// Test generate sendTx with default gas
 	sendTokens := sdk.TokensFromTendermintPower(10)
-	success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--generate-only")
+	success, stdout, stderr := f.TxSend(fooAddr.String(), barAddr, sdk.NewCoin(denom, sendTokens), "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg := unmarshalStdTx(t, stdout)
@@ -678,7 +680,7 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 	require.Equal(t, 0, len(msg.GetSignatures()))
 
 	// Test generate sendTx with --gas=$amount
-	success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=100", "--generate-only")
+	success, stdout, stderr = f.TxSend(fooAddr.String(), barAddr, sdk.NewCoin(denom, sendTokens), "--gas=100", "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg = unmarshalStdTx(t, stdout)
@@ -687,7 +689,7 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 	require.Equal(t, 0, len(msg.GetSignatures()))
 
 	// Test generate sendTx, estimate gas
-	success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=auto", "--generate-only")
+	success, stdout, stderr = f.TxSend(fooAddr.String(), barAddr, sdk.NewCoin(denom, sendTokens), "--gas=auto", "--generate-only")
 	require.True(t, success)
 	require.NotEmpty(t, stderr)
 	msg = unmarshalStdTx(t, stdout)
@@ -764,7 +766,7 @@ func TestGaiaCLIMultisignInsufficientCosigners(t *testing.T) {
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Test generate sendTx with multisig
-	success, stdout, _ := f.TxSend(keyFooBarBaz, barAddr, sdk.NewInt64Coin(denom, 5), "--generate-only")
+	success, stdout, _ := f.TxSend(fooBarBazAddr.String(), barAddr, sdk.NewInt64Coin(denom, 5), "--generate-only")
 	require.True(t, success)
 
 	// Write the output to disk
@@ -808,8 +810,10 @@ func TestGaiaCLIEncode(t *testing.T) {
 
 	// Build a testing transaction and write it to disk
 	barAddr := f.KeyAddress(keyBar)
+	keyAddr := f.KeyAddress(keyFoo)
+
 	sendTokens := sdk.TokensFromTendermintPower(10)
-	success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--generate-only", "--memo", "deadbeef")
+	success, stdout, stderr := f.TxSend(keyAddr.String(), barAddr, sdk.NewCoin(denom, sendTokens), "--generate-only", "--memo", "deadbeef")
 	require.True(t, success)
 	require.Empty(t, stderr)
 
@@ -853,7 +857,7 @@ func TestGaiaCLIMultisignSortSignatures(t *testing.T) {
 	require.Equal(t, int64(10), fooBarBazAcc.GetCoins().AmountOf(denom).Int64())
 
 	// Test generate sendTx with multisig
-	success, stdout, _ := f.TxSend(keyFooBarBaz, barAddr, sdk.NewInt64Coin(denom, 5), "--generate-only")
+	success, stdout, _ := f.TxSend(fooBarBazAddr.String(), barAddr, sdk.NewInt64Coin(denom, 5), "--generate-only")
 	require.True(t, success)
 
 	// Write the output to disk
@@ -915,7 +919,7 @@ func TestGaiaCLIMultisign(t *testing.T) {
 	require.Equal(t, int64(10), fooBarBazAcc.GetCoins().AmountOf(denom).Int64())
 
 	// Test generate sendTx with multisig
-	success, stdout, stderr := f.TxSend(keyFooBarBaz, bazAddr, sdk.NewInt64Coin(denom, 10), "--generate-only")
+	success, stdout, stderr := f.TxSend(fooBarBazAddr.String(), bazAddr, sdk.NewInt64Coin(denom, 10), "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 
@@ -963,6 +967,7 @@ func TestGaiaCLIConfig(t *testing.T) {
 	node := fmt.Sprintf("%s:%s", f.RPCAddr, f.Port)
 
 	// Set available configuration options
+	f.CLIConfig("broadcast-mode", "block")
 	f.CLIConfig("node", node)
 	f.CLIConfig("output", "text")
 	f.CLIConfig("trust-node", "true")
@@ -972,7 +977,8 @@ func TestGaiaCLIConfig(t *testing.T) {
 
 	config, err := ioutil.ReadFile(path.Join(f.GCLIHome, "config", "config.toml"))
 	require.NoError(t, err)
-	expectedConfig := fmt.Sprintf(`chain-id = "%s"
+	expectedConfig := fmt.Sprintf(`broadcast-mode = "block"
+chain-id = "%s"
 indent = true
 node = "%s"
 output = "text"
diff --git a/cmd/gaia/cli_test/test_helpers.go b/cmd/gaia/cli_test/test_helpers.go
index 21419ad96..aac07abb2 100644
--- a/cmd/gaia/cli_test/test_helpers.go
+++ b/cmd/gaia/cli_test/test_helpers.go
@@ -104,15 +104,15 @@ func (f Fixtures) GenesisState() app.GenesisState {
 	return appState
 }
 
-// InitFixtures is called at the beginning of a test
-// and initializes a chain with 1 validator
+// InitFixtures is called at the beginning of a test  and initializes a chain
+// with 1 validator.
 func InitFixtures(t *testing.T) (f *Fixtures) {
 	f = NewFixtures(t)
 
-	// Reset test state
+	// reset test state
 	f.UnsafeResetAll()
 
-	// Ensure keystore has foo and bar keys
+	// ensure keystore has foo and bar keys
 	f.KeysDelete(keyFoo)
 	f.KeysDelete(keyBar)
 	f.KeysDelete(keyBar)
@@ -124,14 +124,16 @@ func InitFixtures(t *testing.T) (f *Fixtures) {
 	f.KeysAdd(keyFooBarBaz, "--multisig-threshold=2", fmt.Sprintf(
 		"--multisig=%s,%s,%s", keyFoo, keyBar, keyBaz))
 
-	// Ensure that CLI output is in JSON format
+	// ensure that CLI output is in JSON format
 	f.CLIConfig("output", "json")
 
 	// NOTE: GDInit sets the ChainID
 	f.GDInit(keyFoo)
-	f.CLIConfig("chain-id", f.ChainID)
 
-	// Start an account with tokens
+	f.CLIConfig("chain-id", f.ChainID)
+	f.CLIConfig("broadcast-mode", "block")
+
+	// start an account with tokens
 	f.AddGenesisAccount(f.KeyAddress(keyFoo), startCoins)
 	f.AddGenesisAccount(
 		f.KeyAddress(keyVesting), startCoins,
@@ -139,8 +141,10 @@ func InitFixtures(t *testing.T) (f *Fixtures) {
 		fmt.Sprintf("--vesting-start-time=%d", time.Now().UTC().UnixNano()),
 		fmt.Sprintf("--vesting-end-time=%d", time.Now().Add(60*time.Second).UTC().UnixNano()),
 	)
+
 	f.GenTx(keyFoo)
 	f.CollectGenTxs()
+
 	return
 }
 
@@ -163,7 +167,7 @@ func (f *Fixtures) Flags() string {
 
 // UnsafeResetAll is gaiad unsafe-reset-all
 func (f *Fixtures) UnsafeResetAll(flags ...string) {
-	cmd := fmt.Sprintf("gaiad --home=%s unsafe-reset-all", f.GDHome)
+	cmd := fmt.Sprintf("../../../build/gaiad --home=%s unsafe-reset-all", f.GDHome)
 	executeWrite(f.T, addFlags(cmd, flags))
 	err := os.RemoveAll(filepath.Join(f.GDHome, "config", "gentx"))
 	require.NoError(f.T, err)
@@ -172,7 +176,7 @@ func (f *Fixtures) UnsafeResetAll(flags ...string) {
 // GDInit is gaiad init
 // NOTE: GDInit sets the ChainID for the Fixtures instance
 func (f *Fixtures) GDInit(moniker string, flags ...string) {
-	cmd := fmt.Sprintf("gaiad init -o --home=%s %s", f.GDHome, moniker)
+	cmd := fmt.Sprintf("../../../build/gaiad init -o --home=%s %s", f.GDHome, moniker)
 	_, stderr := tests.ExecuteT(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 
 	var chainID string
@@ -189,25 +193,25 @@ func (f *Fixtures) GDInit(moniker string, flags ...string) {
 
 // AddGenesisAccount is gaiad add-genesis-account
 func (f *Fixtures) AddGenesisAccount(address sdk.AccAddress, coins sdk.Coins, flags ...string) {
-	cmd := fmt.Sprintf("gaiad add-genesis-account %s %s --home=%s", address, coins, f.GDHome)
+	cmd := fmt.Sprintf("../../../build/gaiad add-genesis-account %s %s --home=%s", address, coins, f.GDHome)
 	executeWriteCheckErr(f.T, addFlags(cmd, flags))
 }
 
 // GenTx is gaiad gentx
 func (f *Fixtures) GenTx(name string, flags ...string) {
-	cmd := fmt.Sprintf("gaiad gentx --name=%s --home=%s --home-client=%s", name, f.GDHome, f.GCLIHome)
+	cmd := fmt.Sprintf("../../../build/gaiad gentx --name=%s --home=%s --home-client=%s", name, f.GDHome, f.GCLIHome)
 	executeWriteCheckErr(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
 // CollectGenTxs is gaiad collect-gentxs
 func (f *Fixtures) CollectGenTxs(flags ...string) {
-	cmd := fmt.Sprintf("gaiad collect-gentxs --home=%s", f.GDHome)
+	cmd := fmt.Sprintf("../../../build/gaiad collect-gentxs --home=%s", f.GDHome)
 	executeWriteCheckErr(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
 // GDStart runs gaiad start with the appropriate flags and returns a process
 func (f *Fixtures) GDStart(flags ...string) *tests.Process {
-	cmd := fmt.Sprintf("gaiad start --home=%s --rpc.laddr=%v --p2p.laddr=%v", f.GDHome, f.RPCAddr, f.P2PAddr)
+	cmd := fmt.Sprintf("../../../build/gaiad start --home=%s --rpc.laddr=%v --p2p.laddr=%v", f.GDHome, f.RPCAddr, f.P2PAddr)
 	proc := tests.GoExecuteTWithStdout(f.T, addFlags(cmd, flags))
 	tests.WaitForTMStart(f.Port)
 	tests.WaitForNextNBlocksTM(1, f.Port)
@@ -216,7 +220,7 @@ func (f *Fixtures) GDStart(flags ...string) *tests.Process {
 
 // GDTendermint returns the results of gaiad tendermint [query]
 func (f *Fixtures) GDTendermint(query string) string {
-	cmd := fmt.Sprintf("gaiad tendermint %s --home=%s", query, f.GDHome)
+	cmd := fmt.Sprintf("../../../build/gaiad tendermint %s --home=%s", query, f.GDHome)
 	success, stdout, stderr := executeWriteRetStdStreams(f.T, cmd)
 	require.Empty(f.T, stderr)
 	require.True(f.T, success)
@@ -225,7 +229,7 @@ func (f *Fixtures) GDTendermint(query string) string {
 
 // ValidateGenesis runs gaiad validate-genesis
 func (f *Fixtures) ValidateGenesis() {
-	cmd := fmt.Sprintf("gaiad validate-genesis --home=%s", f.GDHome)
+	cmd := fmt.Sprintf("../../../build/gaiad validate-genesis --home=%s", f.GDHome)
 	executeWriteCheckErr(f.T, cmd)
 }
 
@@ -234,31 +238,31 @@ func (f *Fixtures) ValidateGenesis() {
 
 // KeysDelete is gaiacli keys delete
 func (f *Fixtures) KeysDelete(name string, flags ...string) {
-	cmd := fmt.Sprintf("gaiacli keys delete --home=%s %s", f.GCLIHome, name)
+	cmd := fmt.Sprintf("../../../build/gaiacli keys delete --home=%s %s", f.GCLIHome, name)
 	executeWrite(f.T, addFlags(cmd, append(append(flags, "-y"), "-f")))
 }
 
 // KeysAdd is gaiacli keys add
 func (f *Fixtures) KeysAdd(name string, flags ...string) {
-	cmd := fmt.Sprintf("gaiacli keys add --home=%s %s", f.GCLIHome, name)
+	cmd := fmt.Sprintf("../../../build/gaiacli keys add --home=%s %s", f.GCLIHome, name)
 	executeWriteCheckErr(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
 // KeysAddRecover prepares gaiacli keys add --recover
 func (f *Fixtures) KeysAddRecover(name, mnemonic string, flags ...string) {
-	cmd := fmt.Sprintf("gaiacli keys add --home=%s --recover %s", f.GCLIHome, name)
+	cmd := fmt.Sprintf("../../../build/gaiacli keys add --home=%s --recover %s", f.GCLIHome, name)
 	executeWriteCheckErr(f.T, addFlags(cmd, flags), app.DefaultKeyPass, mnemonic)
 }
 
 // KeysAddRecoverHDPath prepares gaiacli keys add --recover --account --index
 func (f *Fixtures) KeysAddRecoverHDPath(name, mnemonic string, account uint32, index uint32, flags ...string) {
-	cmd := fmt.Sprintf("gaiacli keys add --home=%s --recover %s --account %d --index %d", f.GCLIHome, name, account, index)
+	cmd := fmt.Sprintf("../../../build/gaiacli keys add --home=%s --recover %s --account %d --index %d", f.GCLIHome, name, account, index)
 	executeWriteCheckErr(f.T, addFlags(cmd, flags), app.DefaultKeyPass, mnemonic)
 }
 
 // KeysShow is gaiacli keys show
 func (f *Fixtures) KeysShow(name string, flags ...string) keys.KeyOutput {
-	cmd := fmt.Sprintf("gaiacli keys show --home=%s %s", f.GCLIHome, name)
+	cmd := fmt.Sprintf("../../../build/gaiacli keys show --home=%s %s", f.GCLIHome, name)
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var ko keys.KeyOutput
 	err := clientkeys.UnmarshalJSON([]byte(out), &ko)
@@ -279,7 +283,7 @@ func (f *Fixtures) KeyAddress(name string) sdk.AccAddress {
 
 // CLIConfig is gaiacli config
 func (f *Fixtures) CLIConfig(key, value string, flags ...string) {
-	cmd := fmt.Sprintf("gaiacli config --home=%s %s %s", f.GCLIHome, key, value)
+	cmd := fmt.Sprintf("../../../build/gaiacli config --home=%s %s %s", f.GCLIHome, key, value)
 	executeWriteCheckErr(f.T, addFlags(cmd, flags))
 }
 
@@ -288,7 +292,7 @@ func (f *Fixtures) CLIConfig(key, value string, flags ...string) {
 
 // TxSend is gaiacli tx send
 func (f *Fixtures) TxSend(from string, to sdk.AccAddress, amount sdk.Coin, flags ...string) (bool, string, string) {
-	cmd := fmt.Sprintf("gaiacli tx send %s %s %v --from=%s", to, amount, f.Flags(), from)
+	cmd := fmt.Sprintf("../../../build/gaiacli tx send %s %s %v --from=%s", to, amount, f.Flags(), from)
 	return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
@@ -296,25 +300,25 @@ func (f *Fixtures) txSendWithConfirm(
 	from string, to sdk.AccAddress, amount sdk.Coin, confirm string, flags ...string,
 ) (bool, string, string) {
 
-	cmd := fmt.Sprintf("gaiacli tx send %s %s %v --from=%s", to, amount, f.Flags(), from)
+	cmd := fmt.Sprintf("../../../build/gaiacli tx send %s %s %v --from=%s", to, amount, f.Flags(), from)
 	return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), confirm, app.DefaultKeyPass)
 }
 
 // TxSign is gaiacli tx sign
 func (f *Fixtures) TxSign(signer, fileName string, flags ...string) (bool, string, string) {
-	cmd := fmt.Sprintf("gaiacli tx sign %v --from=%s %v", f.Flags(), signer, fileName)
+	cmd := fmt.Sprintf("../../../build/gaiacli tx sign %v --from=%s %v", f.Flags(), signer, fileName)
 	return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
 // TxBroadcast is gaiacli tx broadcast
 func (f *Fixtures) TxBroadcast(fileName string, flags ...string) (bool, string, string) {
-	cmd := fmt.Sprintf("gaiacli tx broadcast %v %v", f.Flags(), fileName)
+	cmd := fmt.Sprintf("../../../build/gaiacli tx broadcast %v %v", f.Flags(), fileName)
 	return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
 // TxEncode is gaiacli tx encode
 func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, string) {
-	cmd := fmt.Sprintf("gaiacli tx encode %v %v", f.Flags(), fileName)
+	cmd := fmt.Sprintf("../../../build/gaiacli tx encode %v %v", f.Flags(), fileName)
 	return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
@@ -322,7 +326,7 @@ func (f *Fixtures) TxEncode(fileName string, flags ...string) (bool, string, str
 func (f *Fixtures) TxMultisign(fileName, name string, signaturesFiles []string,
 	flags ...string) (bool, string, string) {
 
-	cmd := fmt.Sprintf("gaiacli tx multisign %v %s %s %s", f.Flags(),
+	cmd := fmt.Sprintf("../../../build/gaiacli tx multisign %v %s %s %s", f.Flags(),
 		fileName, name, strings.Join(signaturesFiles, " "),
 	)
 	return executeWriteRetStdStreams(f.T, cmd)
@@ -333,7 +337,7 @@ func (f *Fixtures) TxMultisign(fileName, name string, signaturesFiles []string,
 
 // TxStakingCreateValidator is gaiacli tx staking create-validator
 func (f *Fixtures) TxStakingCreateValidator(from, consPubKey string, amount sdk.Coin, flags ...string) (bool, string, string) {
-	cmd := fmt.Sprintf("gaiacli tx staking create-validator %v --from=%s --pubkey=%s", f.Flags(), from, consPubKey)
+	cmd := fmt.Sprintf("../../../build/gaiacli tx staking create-validator %v --from=%s --pubkey=%s", f.Flags(), from, consPubKey)
 	cmd += fmt.Sprintf(" --amount=%v --moniker=%v --commission-rate=%v", amount, from, "0.05")
 	cmd += fmt.Sprintf(" --commission-max-rate=%v --commission-max-change-rate=%v", "0.20", "0.10")
 	cmd += fmt.Sprintf(" --min-self-delegation=%v", "1")
@@ -342,7 +346,7 @@ func (f *Fixtures) TxStakingCreateValidator(from, consPubKey string, amount sdk.
 
 // TxStakingUnbond is gaiacli tx staking unbond
 func (f *Fixtures) TxStakingUnbond(from, shares string, validator sdk.ValAddress, flags ...string) bool {
-	cmd := fmt.Sprintf("gaiacli tx staking unbond %s %v --from=%s %v", validator, shares, from, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli tx staking unbond %s %v --from=%s %v", validator, shares, from, f.Flags())
 	return executeWrite(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
@@ -351,20 +355,20 @@ func (f *Fixtures) TxStakingUnbond(from, shares string, validator sdk.ValAddress
 
 // TxGovSubmitProposal is gaiacli tx gov submit-proposal
 func (f *Fixtures) TxGovSubmitProposal(from, typ, title, description string, deposit sdk.Coin, flags ...string) (bool, string, string) {
-	cmd := fmt.Sprintf("gaiacli tx gov submit-proposal %v --from=%s --type=%s", f.Flags(), from, typ)
+	cmd := fmt.Sprintf("../../../build/gaiacli tx gov submit-proposal %v --from=%s --type=%s", f.Flags(), from, typ)
 	cmd += fmt.Sprintf(" --title=%s --description=%s --deposit=%s", title, description, deposit)
 	return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
 // TxGovDeposit is gaiacli tx gov deposit
 func (f *Fixtures) TxGovDeposit(proposalID int, from string, amount sdk.Coin, flags ...string) (bool, string, string) {
-	cmd := fmt.Sprintf("gaiacli tx gov deposit %d %s --from=%s %v", proposalID, amount, from, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli tx gov deposit %d %s --from=%s %v", proposalID, amount, from, f.Flags())
 	return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
 // TxGovVote is gaiacli tx gov vote
 func (f *Fixtures) TxGovVote(proposalID int, option gov.VoteOption, from string, flags ...string) (bool, string, string) {
-	cmd := fmt.Sprintf("gaiacli tx gov vote %d %s --from=%s %v", proposalID, option, from, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli tx gov vote %d %s --from=%s %v", proposalID, option, from, f.Flags())
 	return executeWriteRetStdStreams(f.T, addFlags(cmd, flags), app.DefaultKeyPass)
 }
 
@@ -373,7 +377,7 @@ func (f *Fixtures) TxGovVote(proposalID int, option gov.VoteOption, from string,
 
 // QueryAccount is gaiacli query account
 func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.BaseAccount {
-	cmd := fmt.Sprintf("gaiacli query account %s %v", address, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query account %s %v", address, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var initRes map[string]json.RawMessage
 	err := json.Unmarshal([]byte(out), &initRes)
@@ -392,7 +396,7 @@ func (f *Fixtures) QueryAccount(address sdk.AccAddress, flags ...string) auth.Ba
 
 // QueryTxs is gaiacli query txs
 func (f *Fixtures) QueryTxs(page, limit int, tags ...string) []sdk.TxResponse {
-	cmd := fmt.Sprintf("gaiacli query txs --page=%d --limit=%d --tags='%s' %v", page, limit, queryTags(tags), f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query txs --page=%d --limit=%d --tags='%s' %v", page, limit, queryTags(tags), f.Flags())
 	out, _ := tests.ExecuteT(f.T, cmd, "")
 	var txs []sdk.TxResponse
 	cdc := app.MakeCodec()
@@ -403,7 +407,7 @@ func (f *Fixtures) QueryTxs(page, limit int, tags ...string) []sdk.TxResponse {
 
 // QueryTxsInvalid query txs with wrong parameters and compare expected error
 func (f *Fixtures) QueryTxsInvalid(expectedErr error, page, limit int, tags ...string) {
-	cmd := fmt.Sprintf("gaiacli query txs --page=%d --limit=%d --tags='%s' %v", page, limit, queryTags(tags), f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query txs --page=%d --limit=%d --tags='%s' %v", page, limit, queryTags(tags), f.Flags())
 	_, err := tests.ExecuteT(f.T, cmd, "")
 	require.EqualError(f.T, expectedErr, err)
 }
@@ -413,7 +417,7 @@ func (f *Fixtures) QueryTxsInvalid(expectedErr error, page, limit int, tags ...s
 
 // QueryStakingValidator is gaiacli query staking validator
 func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string) staking.Validator {
-	cmd := fmt.Sprintf("gaiacli query staking validator %s %v", valAddr, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query staking validator %s %v", valAddr, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var validator staking.Validator
 	cdc := app.MakeCodec()
@@ -424,7 +428,7 @@ func (f *Fixtures) QueryStakingValidator(valAddr sdk.ValAddress, flags ...string
 
 // QueryStakingUnbondingDelegationsFrom is gaiacli query staking unbonding-delegations-from
 func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress, flags ...string) []staking.UnbondingDelegation {
-	cmd := fmt.Sprintf("gaiacli query staking unbonding-delegations-from %s %v", valAddr, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query staking unbonding-delegations-from %s %v", valAddr, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var ubds []staking.UnbondingDelegation
 	cdc := app.MakeCodec()
@@ -435,7 +439,7 @@ func (f *Fixtures) QueryStakingUnbondingDelegationsFrom(valAddr sdk.ValAddress,
 
 // QueryStakingDelegationsTo is gaiacli query staking delegations-to
 func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...string) []staking.Delegation {
-	cmd := fmt.Sprintf("gaiacli query staking delegations-to %s %v", valAddr, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query staking delegations-to %s %v", valAddr, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var delegations []staking.Delegation
 	cdc := app.MakeCodec()
@@ -446,7 +450,7 @@ func (f *Fixtures) QueryStakingDelegationsTo(valAddr sdk.ValAddress, flags ...st
 
 // QueryStakingPool is gaiacli query staking pool
 func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool {
-	cmd := fmt.Sprintf("gaiacli query staking pool %v", f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query staking pool %v", f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var pool staking.Pool
 	cdc := app.MakeCodec()
@@ -457,7 +461,7 @@ func (f *Fixtures) QueryStakingPool(flags ...string) staking.Pool {
 
 // QueryStakingParameters is gaiacli query staking parameters
 func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params {
-	cmd := fmt.Sprintf("gaiacli query staking params %v", f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query staking params %v", f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var params staking.Params
 	cdc := app.MakeCodec()
@@ -471,7 +475,7 @@ func (f *Fixtures) QueryStakingParameters(flags ...string) staking.Params {
 
 // QueryGovParamDeposit is gaiacli query gov param deposit
 func (f *Fixtures) QueryGovParamDeposit() gov.DepositParams {
-	cmd := fmt.Sprintf("gaiacli query gov param deposit %s", f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov param deposit %s", f.Flags())
 	out, _ := tests.ExecuteT(f.T, cmd, "")
 	var depositParam gov.DepositParams
 	cdc := app.MakeCodec()
@@ -482,7 +486,7 @@ func (f *Fixtures) QueryGovParamDeposit() gov.DepositParams {
 
 // QueryGovParamVoting is gaiacli query gov param voting
 func (f *Fixtures) QueryGovParamVoting() gov.VotingParams {
-	cmd := fmt.Sprintf("gaiacli query gov param voting %s", f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov param voting %s", f.Flags())
 	out, _ := tests.ExecuteT(f.T, cmd, "")
 	var votingParam gov.VotingParams
 	cdc := app.MakeCodec()
@@ -493,7 +497,7 @@ func (f *Fixtures) QueryGovParamVoting() gov.VotingParams {
 
 // QueryGovParamTallying is gaiacli query gov param tallying
 func (f *Fixtures) QueryGovParamTallying() gov.TallyParams {
-	cmd := fmt.Sprintf("gaiacli query gov param tallying %s", f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov param tallying %s", f.Flags())
 	out, _ := tests.ExecuteT(f.T, cmd, "")
 	var tallyingParam gov.TallyParams
 	cdc := app.MakeCodec()
@@ -504,7 +508,7 @@ func (f *Fixtures) QueryGovParamTallying() gov.TallyParams {
 
 // QueryGovProposals is gaiacli query gov proposals
 func (f *Fixtures) QueryGovProposals(flags ...string) gov.Proposals {
-	cmd := fmt.Sprintf("gaiacli query gov proposals %v", f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov proposals %v", f.Flags())
 	stdout, stderr := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	if strings.Contains(stderr, "No matching proposals found") {
 		return gov.Proposals{}
@@ -519,7 +523,7 @@ func (f *Fixtures) QueryGovProposals(flags ...string) gov.Proposals {
 
 // QueryGovProposal is gaiacli query gov proposal
 func (f *Fixtures) QueryGovProposal(proposalID int, flags ...string) gov.Proposal {
-	cmd := fmt.Sprintf("gaiacli query gov proposal %d %v", proposalID, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov proposal %d %v", proposalID, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var proposal gov.Proposal
 	cdc := app.MakeCodec()
@@ -530,7 +534,7 @@ func (f *Fixtures) QueryGovProposal(proposalID int, flags ...string) gov.Proposa
 
 // QueryGovVote is gaiacli query gov vote
 func (f *Fixtures) QueryGovVote(proposalID int, voter sdk.AccAddress, flags ...string) gov.Vote {
-	cmd := fmt.Sprintf("gaiacli query gov vote %d %s %v", proposalID, voter, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov vote %d %s %v", proposalID, voter, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var vote gov.Vote
 	cdc := app.MakeCodec()
@@ -541,7 +545,7 @@ func (f *Fixtures) QueryGovVote(proposalID int, voter sdk.AccAddress, flags ...s
 
 // QueryGovVotes is gaiacli query gov votes
 func (f *Fixtures) QueryGovVotes(proposalID int, flags ...string) []gov.Vote {
-	cmd := fmt.Sprintf("gaiacli query gov votes %d %v", proposalID, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov votes %d %v", proposalID, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var votes []gov.Vote
 	cdc := app.MakeCodec()
@@ -552,7 +556,7 @@ func (f *Fixtures) QueryGovVotes(proposalID int, flags ...string) []gov.Vote {
 
 // QueryGovDeposit is gaiacli query gov deposit
 func (f *Fixtures) QueryGovDeposit(proposalID int, depositor sdk.AccAddress, flags ...string) gov.Deposit {
-	cmd := fmt.Sprintf("gaiacli query gov deposit %d %s %v", proposalID, depositor, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov deposit %d %s %v", proposalID, depositor, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var deposit gov.Deposit
 	cdc := app.MakeCodec()
@@ -563,7 +567,7 @@ func (f *Fixtures) QueryGovDeposit(proposalID int, depositor sdk.AccAddress, fla
 
 // QueryGovDeposits is gaiacli query gov deposits
 func (f *Fixtures) QueryGovDeposits(propsalID int, flags ...string) []gov.Deposit {
-	cmd := fmt.Sprintf("gaiacli query gov deposits %d %v", propsalID, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query gov deposits %d %v", propsalID, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 	var deposits []gov.Deposit
 	cdc := app.MakeCodec()
@@ -577,7 +581,7 @@ func (f *Fixtures) QueryGovDeposits(propsalID int, flags ...string) []gov.Deposi
 
 // QuerySigningInfo returns the signing info for a validator
 func (f *Fixtures) QuerySigningInfo(val string) slashing.ValidatorSigningInfo {
-	cmd := fmt.Sprintf("gaiacli query slashing signing-info %s %s", val, f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query slashing signing-info %s %s", val, f.Flags())
 	res, errStr := tests.ExecuteT(f.T, cmd, "")
 	require.Empty(f.T, errStr)
 	cdc := app.MakeCodec()
@@ -589,7 +593,7 @@ func (f *Fixtures) QuerySigningInfo(val string) slashing.ValidatorSigningInfo {
 
 // QuerySlashingParams is gaiacli query slashing params
 func (f *Fixtures) QuerySlashingParams() slashing.Params {
-	cmd := fmt.Sprintf("gaiacli query slashing params %s", f.Flags())
+	cmd := fmt.Sprintf("../../../build/gaiacli query slashing params %s", f.Flags())
 	res, errStr := tests.ExecuteT(f.T, cmd, "")
 	require.Empty(f.T, errStr)
 	cdc := app.MakeCodec()
diff --git a/cmd/gaia/cmd/gaiacli/main.go b/cmd/gaia/cmd/gaiacli/main.go
index 8bdd645e9..b440db8f9 100644
--- a/cmd/gaia/cmd/gaiacli/main.go
+++ b/cmd/gaia/cmd/gaiacli/main.go
@@ -6,11 +6,13 @@ import (
 	"os"
 	"path"
 
+	"github.com/cosmos/cosmos-sdk/x/mint"
+
 	"github.com/rakyll/statik/fs"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tendermint/libs/cli"
 
 	"github.com/cosmos/cosmos-sdk/client"
@@ -28,6 +30,7 @@ import (
 	dist "github.com/cosmos/cosmos-sdk/x/distribution/client/rest"
 	gv "github.com/cosmos/cosmos-sdk/x/gov"
 	gov "github.com/cosmos/cosmos-sdk/x/gov/client/rest"
+	mintrest "github.com/cosmos/cosmos-sdk/x/mint/client/rest"
 	sl "github.com/cosmos/cosmos-sdk/x/slashing"
 	slashing "github.com/cosmos/cosmos-sdk/x/slashing/client/rest"
 	st "github.com/cosmos/cosmos-sdk/x/staking"
@@ -35,11 +38,13 @@ import (
 
 	authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli"
 	bankcmd "github.com/cosmos/cosmos-sdk/x/bank/client/cli"
+	crisisclient "github.com/cosmos/cosmos-sdk/x/crisis/client"
 	distcmd "github.com/cosmos/cosmos-sdk/x/distribution"
 	distClient "github.com/cosmos/cosmos-sdk/x/distribution/client"
 	govClient "github.com/cosmos/cosmos-sdk/x/gov/client"
-	slashingClient "github.com/cosmos/cosmos-sdk/x/slashing/client"
-	stakingClient "github.com/cosmos/cosmos-sdk/x/staking/client"
+	mintclient "github.com/cosmos/cosmos-sdk/x/mint/client"
+	slashingclient "github.com/cosmos/cosmos-sdk/x/slashing/client"
+	stakingclient "github.com/cosmos/cosmos-sdk/x/staking/client"
 
 	_ "github.com/cosmos/cosmos-sdk/client/lcd/statik"
 )
@@ -67,8 +72,10 @@ func main() {
 	mc := []sdk.ModuleClients{
 		govClient.NewModuleClient(gv.StoreKey, cdc),
 		distClient.NewModuleClient(distcmd.StoreKey, cdc),
-		stakingClient.NewModuleClient(st.StoreKey, cdc),
-		slashingClient.NewModuleClient(sl.StoreKey, cdc),
+		stakingclient.NewModuleClient(st.StoreKey, cdc),
+		mintclient.NewModuleClient(mint.StoreKey, cdc),
+		slashingclient.NewModuleClient(sl.StoreKey, cdc),
+		crisisclient.NewModuleClient(sl.StoreKey, cdc),
 	}
 
 	rootCmd := &cobra.Command{
@@ -124,7 +131,10 @@ func queryCmd(cdc *amino.Codec, mc []sdk.ModuleClients) *cobra.Command {
 	)
 
 	for _, m := range mc {
-		queryCmd.AddCommand(m.GetQueryCmd())
+		mQueryCmd := m.GetQueryCmd()
+		if mQueryCmd != nil {
+			queryCmd.AddCommand(mQueryCmd)
+		}
 	}
 
 	return queryCmd
@@ -166,6 +176,7 @@ func registerRoutes(rs *lcd.RestServer) {
 	staking.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
 	slashing.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
 	gov.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
+	mintrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
 }
 
 func registerSwaggerUI(rs *lcd.RestServer) {
diff --git a/cmd/gaia/cmd/gaiad/main.go b/cmd/gaia/cmd/gaiad/main.go
index d6d88e0df..b515f5236 100644
--- a/cmd/gaia/cmd/gaiad/main.go
+++ b/cmd/gaia/cmd/gaiad/main.go
@@ -22,6 +22,11 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+// gaiad custom flags
+const flagAssertInvariantsBlockly = "assert-invariants-blockly"
+
+var assertInvariantsBlockly bool
+
 func main() {
 	cdc := app.MakeCodec()
 
@@ -50,6 +55,8 @@ func main() {
 
 	// prepare and add flags
 	executor := cli.PrepareBaseCmd(rootCmd, "GA", app.DefaultNodeHome)
+	rootCmd.PersistentFlags().BoolVar(&assertInvariantsBlockly, flagAssertInvariantsBlockly,
+		false, "Assert registered invariants on a blockly basis")
 	err := executor.Execute()
 	if err != nil {
 		// handle with #870
@@ -59,7 +66,7 @@ func main() {
 
 func newApp(logger log.Logger, db dbm.DB, traceStore io.Writer) abci.Application {
 	return app.NewGaiaApp(
-		logger, db, traceStore, true,
+		logger, db, traceStore, true, assertInvariantsBlockly,
 		baseapp.SetPruning(store.NewPruningOptionsFromString(viper.GetString("pruning"))),
 		baseapp.SetMinGasPrices(viper.GetString(server.FlagMinGasPrices)),
 	)
@@ -68,14 +75,15 @@ func newApp(logger log.Logger, db dbm.DB, traceStore io.Writer) abci.Application
 func exportAppStateAndTMValidators(
 	logger log.Logger, db dbm.DB, traceStore io.Writer, height int64, forZeroHeight bool, jailWhiteList []string,
 ) (json.RawMessage, []tmtypes.GenesisValidator, error) {
+
 	if height != -1 {
-		gApp := app.NewGaiaApp(logger, db, traceStore, false)
+		gApp := app.NewGaiaApp(logger, db, traceStore, false, false)
 		err := gApp.LoadHeight(height)
 		if err != nil {
 			return nil, nil, err
 		}
 		return gApp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList)
 	}
-	gApp := app.NewGaiaApp(logger, db, traceStore, true)
+	gApp := app.NewGaiaApp(logger, db, traceStore, true, false)
 	return gApp.ExportAppStateAndValidators(forZeroHeight, jailWhiteList)
 }
diff --git a/cmd/gaia/cmd/gaiareplay/main.go b/cmd/gaia/cmd/gaiareplay/main.go
index 78cacec36..fd2c518a4 100644
--- a/cmd/gaia/cmd/gaiareplay/main.go
+++ b/cmd/gaia/cmd/gaiareplay/main.go
@@ -107,7 +107,7 @@ func run(rootDir string) {
 	// Application
 	fmt.Println("Creating application")
 	myapp := app.NewGaiaApp(
-		ctx.Logger, appDB, traceStoreWriter, true,
+		ctx.Logger, appDB, traceStoreWriter, true, true,
 		baseapp.SetPruning(store.PruneEverything), // nothing
 	)
 
diff --git a/cmd/gaia/init/genesis_accts_test.go b/cmd/gaia/init/genesis_accts_test.go
index 2c17acc54..74af5a42b 100644
--- a/cmd/gaia/init/genesis_accts_test.go
+++ b/cmd/gaia/init/genesis_accts_test.go
@@ -32,8 +32,8 @@ func TestAddGenesisAccount(t *testing.T) {
 			args{
 				app.GenesisState{},
 				addr1,
-				sdk.Coins{},
-				sdk.Coins{},
+				sdk.NewCoins(),
+				sdk.NewCoins(),
 				0,
 				0,
 			},
@@ -44,8 +44,8 @@ func TestAddGenesisAccount(t *testing.T) {
 			args{
 				app.GenesisState{Accounts: []app.GenesisAccount{{Address: addr1}}},
 				addr1,
-				sdk.Coins{},
-				sdk.Coins{},
+				sdk.NewCoins(),
+				sdk.NewCoins(),
 				0,
 				0,
 			},
@@ -56,8 +56,8 @@ func TestAddGenesisAccount(t *testing.T) {
 			args{
 				app.GenesisState{},
 				addr1,
-				sdk.Coins{sdk.NewInt64Coin("stake", 50)},
-				sdk.Coins{sdk.NewInt64Coin("stake", 100)},
+				sdk.NewCoins(sdk.NewInt64Coin("stake", 50)),
+				sdk.NewCoins(sdk.NewInt64Coin("stake", 100)),
 				0,
 				0,
 			},
@@ -68,8 +68,8 @@ func TestAddGenesisAccount(t *testing.T) {
 			args{
 				app.GenesisState{},
 				addr1,
-				sdk.Coins{sdk.NewInt64Coin("stake", 50)},
-				sdk.Coins{sdk.NewInt64Coin("stake", 50)},
+				sdk.NewCoins(sdk.NewInt64Coin("stake", 50)),
+				sdk.NewCoins(sdk.NewInt64Coin("stake", 50)),
 				1654668078,
 				1554668078,
 			},
diff --git a/cmd/gaia/init/gentx.go b/cmd/gaia/init/gentx.go
index 6ce4badec..970c77e0d 100644
--- a/cmd/gaia/init/gentx.go
+++ b/cmd/gaia/init/gentx.go
@@ -47,6 +47,7 @@ func GenTxCmd(ctx *server.Context, cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "gentx",
 		Short: "Generate a genesis tx carrying a self delegation",
+		Args:  cobra.NoArgs,
 		Long: fmt.Sprintf(`This command is an alias of the 'gaiad tx create-validator' command'.
 
 It creates a genesis piece carrying a self delegation with the
@@ -88,6 +89,10 @@ following delegation and commission default parameters:
 				return err
 			}
 
+			if err = app.GaiaValidateGenesisState(genesisState); err != nil {
+				return err
+			}
+
 			kb, err := keys.NewKeyBaseFromDir(viper.GetString(flagClientHome))
 			if err != nil {
 				return err
@@ -107,8 +112,12 @@ following delegation and commission default parameters:
 				}
 			}
 
+			website := viper.GetString(cli.FlagWebsite)
+			details := viper.GetString(cli.FlagDetails)
+			identity := viper.GetString(cli.FlagIdentity)
+
 			// Set flags for creating gentx
-			prepareFlagsForTxCreateValidator(config, nodeID, ip, genDoc.ChainID, valPubKey)
+			prepareFlagsForTxCreateValidator(config, nodeID, ip, genDoc.ChainID, valPubKey, website, details, identity)
 
 			// Fetch the amount of coins staked
 			amount := viper.GetString(cli.FlagAmount)
@@ -122,9 +131,17 @@ following delegation and commission default parameters:
 				return err
 			}
 
-			// Run gaiad tx create-validator
 			txBldr := authtxb.NewTxBuilderFromCLI().WithTxEncoder(utils.GetTxEncoder(cdc))
 			cliCtx := context.NewCLIContext().WithCodec(cdc)
+
+			// XXX: Set the generate-only flag here after the CLI context has
+			// been created. This allows the from name/key to be correctly populated.
+			//
+			// TODO: Consider removing the manual setting of generate-only in
+			// favor of a 'gentx' flag in the create-validator command.
+			viper.Set(client.FlagGenerateOnly, true)
+
+			// create a 'create-validator' message
 			txBldr, msg, err := cli.BuildCreateValidatorMsg(cliCtx, txBldr)
 			if err != nil {
 				return err
@@ -188,6 +205,9 @@ following delegation and commission default parameters:
 		"write the genesis transaction JSON document to the given file instead of the default location")
 	cmd.Flags().String(cli.FlagIP, ip, "The node's public IP")
 	cmd.Flags().String(cli.FlagNodeID, "", "The node's NodeID")
+	cmd.Flags().String(cli.FlagWebsite, "", "The validator's (optional) website")
+	cmd.Flags().String(cli.FlagDetails, "", "The validator's (optional) details")
+	cmd.Flags().String(cli.FlagIdentity, "", "The (optional) identity signature (ex. UPort or Keybase)")
 	cmd.Flags().AddFlagSet(cli.FsCommissionCreate)
 	cmd.Flags().AddFlagSet(cli.FsMinSelfDelegation)
 	cmd.Flags().AddFlagSet(cli.FsAmount)
@@ -224,16 +244,20 @@ func accountInGenesis(genesisState app.GenesisState, key sdk.AccAddress, coins s
 	return fmt.Errorf("account %s in not in the app_state.accounts array of genesis.json", key)
 }
 
-func prepareFlagsForTxCreateValidator(config *cfg.Config, nodeID, ip, chainID string,
-	valPubKey crypto.PubKey) {
-	viper.Set(tmcli.HomeFlag, viper.GetString(flagClientHome)) // --home
+func prepareFlagsForTxCreateValidator(
+	config *cfg.Config, nodeID, ip, chainID string, valPubKey crypto.PubKey, website, details, identity string,
+) {
+	viper.Set(tmcli.HomeFlag, viper.GetString(flagClientHome))
 	viper.Set(client.FlagChainID, chainID)
-	viper.Set(client.FlagFrom, viper.GetString(client.FlagName))   // --from
-	viper.Set(cli.FlagNodeID, nodeID)                              // --node-id
-	viper.Set(cli.FlagIP, ip)                                      // --ip
-	viper.Set(cli.FlagPubKey, sdk.MustBech32ifyConsPub(valPubKey)) // --pubkey
-	viper.Set(client.FlagGenerateOnly, true)                       // --genesis-format
-	viper.Set(cli.FlagMoniker, config.Moniker)                     // --moniker
+	viper.Set(client.FlagFrom, viper.GetString(client.FlagName))
+	viper.Set(cli.FlagNodeID, nodeID)
+	viper.Set(cli.FlagIP, ip)
+	viper.Set(cli.FlagPubKey, sdk.MustBech32ifyConsPub(valPubKey))
+	viper.Set(cli.FlagMoniker, config.Moniker)
+	viper.Set(cli.FlagWebsite, website)
+	viper.Set(cli.FlagDetails, details)
+	viper.Set(cli.FlagIdentity, identity)
+
 	if config.Moniker == "" {
 		viper.Set(cli.FlagMoniker, viper.GetString(client.FlagName))
 	}
diff --git a/cmd/gaia/init/gentx_test.go b/cmd/gaia/init/gentx_test.go
new file mode 100644
index 000000000..d99a562fc
--- /dev/null
+++ b/cmd/gaia/init/gentx_test.go
@@ -0,0 +1,85 @@
+package init
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/server"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/staking/client/cli"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
+	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/libs/log"
+)
+
+func Test_prepareFlagsForTxCreateValidator(t *testing.T) {
+	defer server.SetupViper(t)()
+	defer setupClientHome(t)()
+	config, err := tcmd.ParseConfig()
+	require.Nil(t, err)
+	logger := log.NewNopLogger()
+	ctx := server.NewContext(config, logger)
+
+	valPubKey, _ := sdk.GetConsPubKeyBech32("cosmosvalconspub1zcjduepq7jsrkl9fgqk0wj3ahmfr8pgxj6vakj2wzn656s8pehh0zhv2w5as5gd80a")
+
+	type args struct {
+		config    *cfg.Config
+		nodeID    string
+		ip        string
+		chainID   string
+		valPubKey crypto.PubKey
+		website   string
+		details   string
+		identity  string
+	}
+
+	type extraParams struct {
+		amount                  string
+		commissionRate          string
+		commissionMaxRate       string
+		commissionMaxChangeRate string
+		minSelfDelegation       string
+	}
+
+	type testcase struct {
+		name string
+		args args
+	}
+
+	runTest := func(t *testing.T, tt testcase, params extraParams) {
+		prepareFlagsForTxCreateValidator(tt.args.config, tt.args.nodeID, tt.args.ip, tt.args.chainID, tt.args.valPubKey, tt.args.website, tt.args.details, tt.args.identity)
+		require.Equal(t, tt.args.website, viper.GetString(cli.FlagWebsite))
+		require.Equal(t, tt.args.details, viper.GetString(cli.FlagDetails))
+		require.Equal(t, tt.args.identity, viper.GetString(cli.FlagIdentity))
+		require.Equal(t, params.amount, viper.GetString(cli.FlagAmount))
+		require.Equal(t, params.commissionRate, viper.GetString(cli.FlagCommissionRate))
+		require.Equal(t, params.commissionMaxRate, viper.GetString(cli.FlagCommissionMaxRate))
+		require.Equal(t, params.commissionMaxChangeRate, viper.GetString(cli.FlagCommissionMaxChangeRate))
+		require.Equal(t, params.minSelfDelegation, viper.GetString(cli.FlagMinSelfDelegation))
+	}
+
+	tests := []testcase{
+		{"No parameters", args{ctx.Config, "X", "0.0.0.0", "chainId", valPubKey, "", "", ""}},
+		{"Optional parameters fed", args{ctx.Config, "X", "0.0.0.0", "chainId", valPubKey, "cosmos.network", "details", "identity"}},
+	}
+
+	defaultParams := extraParams{defaultAmount, defaultCommissionRate, defaultCommissionMaxRate, defaultCommissionMaxChangeRate, defaultMinSelfDelegation}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Run(tt.name, func(t *testing.T) { runTest(t, tt, defaultParams) })
+		})
+	}
+
+	// Override default params
+	params := extraParams{"5stake", "1.0", "1.0", "1.0", "1.0"}
+	viper.Set(cli.FlagAmount, params.amount)
+	viper.Set(cli.FlagCommissionRate, params.commissionRate)
+	viper.Set(cli.FlagCommissionMaxRate, params.commissionMaxRate)
+	viper.Set(cli.FlagCommissionMaxChangeRate, params.commissionMaxChangeRate)
+	viper.Set(cli.FlagMinSelfDelegation, params.minSelfDelegation)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) { runTest(t, tt, params) })
+	}
+}
diff --git a/cmd/gosum/main.go b/cmd/gosum/main.go
new file mode 100644
index 000000000..f1c280051
--- /dev/null
+++ b/cmd/gosum/main.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"log"
+	"os"
+)
+
+// DONTCOVER
+
+// nolint: errcheck
+func main() {
+	f, err := os.Open(os.Args[1])
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+
+	h := sha256.New()
+	if _, err := io.Copy(h, f); err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Printf("%x", h.Sum(nil))
+}
diff --git a/cmd/sdkch/README.md b/cmd/sdkch/README.md
new file mode 100644
index 000000000..204b67f55
--- /dev/null
+++ b/cmd/sdkch/README.md
@@ -0,0 +1,50 @@
+# sdkch
+Simple tool to maintain modular changelogs
+
+# Usage
+
+```
+$ sdkch -help
+usage: sdkch [-d directory] [-prune] command
+
+Maintain unreleased changelog entries in a modular fashion.
+
+Commands:
+    add section stanza [message]    Add an entry file.
+                                    If message is empty, start the editor to edit
+                                    the message.
+    generate [version]              Generate a changelog in Markdown format and print
+                                    it to STDOUT. version defaults to UNRELEASED.
+
+    Sections             Stanzas
+         ---                 ---
+    breaking                gaia
+    features             gaiacli
+improvements            gaiarest
+    bugfixes                 sdk
+                      tendermint
+
+Flags:
+  -d string
+    	entry files directory (default "/home/alessio/work/tendermint/src/github.com/cosmos/cosmos-sdk/.pending")
+  -prune
+    	prune old entries after changelog generation
+```
+
+## Add a new entry
+
+You can either drop a text file in the appropriate directory or use the `add` command:
+
+```bash
+$ sdkch add features gaiacli '#3452 New cool gaiacli command'
+```
+
+If no message is provided, a new entry file is opened in an editor is started
+
+## Generate the full changelog
+
+```bash
+$ sdkch generate v0.30.0
+```
+
+The `-prune` flag would remove the old entry files after the changelog is generated.
diff --git a/cmd/sdkch/main.go b/cmd/sdkch/main.go
new file mode 100644
index 000000000..df3a78145
--- /dev/null
+++ b/cmd/sdkch/main.go
@@ -0,0 +1,378 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"math"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+const (
+	entriesDirName         = ".pending"
+	ghLinkPattern          = `#([0-9]+)`
+	ghLinkExpanded         = `[\#$1](https://github.com/cosmos/cosmos-sdk/issues/$1)`
+	maxEntryFilenameLength = 20
+)
+
+var (
+	progName   string
+	verboseLog *log.Logger
+
+	entriesDir     string
+	verboseLogging bool
+
+	// sections name-title map
+	sections = map[string]string{
+		"breaking":     "Breaking Changes",
+		"features":     "New features",
+		"improvements": "Improvements",
+		"bugfixes":     "Bugfixes",
+	}
+	// stanzas name-title map
+	stanzas = map[string]string{
+		"gaia":       "Gaia",
+		"gaiacli":    "Gaia CLI",
+		"gaiarest":   "Gaia REST API",
+		"sdk":        "SDK",
+		"tendermint": "Tendermint",
+	}
+)
+
+func init() {
+	progName = filepath.Base(os.Args[0])
+	cwd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	flag.StringVar(&entriesDir, "d", filepath.Join(cwd, entriesDirName), "entry files directory")
+	flag.BoolVar(&verboseLogging, "v", false, "enable verbose logging")
+	flag.Usage = printUsage
+
+}
+
+func main() {
+	logPrefix := fmt.Sprintf("%s: ", filepath.Base(progName))
+	log.SetFlags(0)
+	log.SetPrefix(logPrefix)
+	flag.Parse()
+	verboseLog = log.New(ioutil.Discard, "", 0)
+	if verboseLogging {
+		verboseLog.SetOutput(os.Stderr)
+		verboseLog.SetPrefix(logPrefix)
+	}
+
+	if flag.NArg() < 1 {
+		errInsufficientArgs()
+	}
+
+	cmd := flag.Arg(0)
+	switch cmd {
+
+	case "add":
+		if flag.NArg() < 3 {
+			errInsufficientArgs()
+		}
+		if flag.NArg() > 4 {
+			errTooManyArgs()
+		}
+		sectionDir, stanzaDir := flag.Arg(1), flag.Arg(2)
+		validateSectionStanzaDirs(sectionDir, stanzaDir)
+		if flag.NArg() == 4 {
+			addSinglelineEntryFile(sectionDir, stanzaDir, strings.TrimSpace(flag.Arg(3)))
+			return
+		}
+		addEntryFile(sectionDir, stanzaDir)
+
+	case "generate":
+		version := "UNRELEASED"
+		if flag.NArg() > 1 {
+			version = strings.Join(flag.Args()[1:], " ")
+		}
+		generateChangelog(version)
+
+	case "prune":
+		pruneEmptyDirectories()
+
+	default:
+		unknownCommand(cmd)
+	}
+}
+
+func addSinglelineEntryFile(sectionDir, stanzaDir, message string) {
+	filename := filepath.Join(
+		filepath.Join(entriesDir, sectionDir, stanzaDir),
+		generateFileName(message),
+	)
+
+	writeEntryFile(filename, []byte(message))
+}
+
+func addEntryFile(sectionDir, stanzaDir string) {
+	bs := readUserInput()
+	firstLine := strings.TrimSpace(strings.Split(string(bs), "\n")[0])
+	filename := filepath.Join(
+		filepath.Join(entriesDir, sectionDir, stanzaDir),
+		generateFileName(firstLine),
+	)
+
+	writeEntryFile(filename, bs)
+}
+
+var filenameInvalidChars = regexp.MustCompile(`[^a-zA-Z0-9-_]`)
+
+func generateFileName(line string) string {
+	var chunks []string
+	subsWithInvalidCharsRemoved := strings.Split(filenameInvalidChars.ReplaceAllString(line, " "), " ")
+	for _, sub := range subsWithInvalidCharsRemoved {
+		sub = strings.TrimSpace(sub)
+		if len(sub) != 0 {
+			chunks = append(chunks, sub)
+		}
+	}
+
+	ret := strings.Join(chunks, "-")
+	return ret[:int(math.Min(float64(len(ret)), float64(maxEntryFilenameLength)))]
+}
+
+func directoryContents(dirPath string) []os.FileInfo {
+	contents, err := ioutil.ReadDir(dirPath)
+	if err != nil && !os.IsNotExist(err) {
+		log.Fatalf("couldn't read directory %s: %v", dirPath, err)
+	}
+
+	if len(contents) == 0 {
+		return nil
+	}
+
+	// Filter out hidden files
+	newContents := contents[:0]
+	for _, f := range contents {
+		if f.Name()[0] != '.' { // skip hidden files
+			newContents = append(newContents, f)
+		}
+	}
+	for i := len(newContents); i < len(contents); i++ {
+		contents[i] = nil
+	}
+
+	return newContents
+}
+
+func generateChangelog(version string) {
+	fmt.Printf("# %s\n\n", version)
+	for sectionDir, sectionTitle := range sections {
+		sectionTitlePrinted := false
+		for stanzaDir, stanzaTitle := range stanzas {
+			path := filepath.Join(entriesDir, sectionDir, stanzaDir)
+			files := directoryContents(path)
+			if len(files) == 0 {
+				continue
+			}
+
+			if !sectionTitlePrinted {
+				fmt.Printf("## %s\n\n", sectionTitle)
+				sectionTitlePrinted = true
+			}
+
+			fmt.Printf("### %s\n\n", stanzaTitle)
+			for _, f := range files {
+				verboseLog.Println("processing", f.Name())
+				filename := filepath.Join(path, f.Name())
+				if err := indentAndPrintFile(filename); err != nil {
+					log.Fatal(err)
+				}
+			}
+
+			fmt.Println()
+		}
+	}
+}
+
+func pruneEmptyDirectories() {
+	for sectionDir, _ := range sections {
+		for stanzaDir, _ := range stanzas {
+			mustPruneDirIfEmpty(filepath.Join(entriesDir, sectionDir, stanzaDir))
+		}
+		mustPruneDirIfEmpty(filepath.Join(entriesDir, sectionDir))
+	}
+}
+
+// nolint: errcheck
+func indentAndPrintFile(filename string) error {
+	file, err := os.Open(filename)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	firstLine := true
+	ghLinkRe := regexp.MustCompile(ghLinkPattern)
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if len(line) == 0 {
+			continue
+		}
+
+		linkified := ghLinkRe.ReplaceAllString(line, ghLinkExpanded)
+		if firstLine {
+			fmt.Printf("* %s\n", linkified)
+			firstLine = false
+			continue
+		}
+
+		fmt.Printf("  %s\n", linkified)
+	}
+
+	return scanner.Err()
+}
+
+// nolint: errcheck
+func writeEntryFile(filename string, bs []byte) {
+	if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
+		log.Fatal(err)
+	}
+	outFile, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer outFile.Close()
+
+	if _, err := outFile.Write(bs); err != nil {
+		log.Fatal(err)
+	}
+
+	log.Printf("Unreleased changelog entry written to: %s\n", filename)
+	log.Println("To modify this entry please edit or delete the above file directly.")
+}
+
+func validateSectionStanzaDirs(sectionDir, stanzaDir string) {
+	if _, ok := sections[sectionDir]; !ok {
+		log.Fatalf("invalid section -- %s", sectionDir)
+	}
+	if _, ok := stanzas[stanzaDir]; !ok {
+		log.Fatalf("invalid stanza -- %s", stanzaDir)
+	}
+}
+
+// nolint: errcheck
+func readUserInput() []byte {
+	tempfilename, err := launchUserEditor()
+	if err != nil {
+		log.Fatalf("couldn't open an editor: %v", err)
+	}
+	defer os.Remove(tempfilename)
+	bs, err := ioutil.ReadFile(tempfilename)
+	if err != nil {
+		log.Fatalf("error: %v", err)
+	}
+	return bs
+}
+
+// nolint: errcheck
+func launchUserEditor() (string, error) {
+	editor, err := exec.LookPath("editor")
+	if err != nil {
+		editor = ""
+	}
+	if editor == "" {
+		editor = os.Getenv("VISUAL")
+	}
+	if editor == "" {
+		editor = os.Getenv("EDITOR")
+	}
+	if editor == "" {
+		return "", errors.New("no editor set, make sure that either " +
+			"VISUAL or EDITOR variables is set and pointing to a correct editor")
+	}
+
+	tempfile, err := ioutil.TempFile("", "sdkch_*")
+	tempfilename := tempfile.Name()
+	if err != nil {
+		return "", err
+	}
+	tempfile.Close()
+
+	cmd := exec.Command(editor, tempfilename)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	if err := cmd.Run(); err != nil {
+		os.Remove(tempfilename)
+		return "", err
+	}
+
+	fileInfo, err := os.Stat(tempfilename)
+	if err != nil {
+		os.Remove(tempfilename)
+		return "", err
+	}
+	if fileInfo.Size() == 0 {
+		log.Fatal("aborting due to empty message")
+	}
+
+	return tempfilename, nil
+}
+
+func mustPruneDirIfEmpty(path string) {
+	if contents := directoryContents(path); len(contents) == 0 {
+		if err := os.Remove(path); err != nil {
+			if !os.IsNotExist(err) {
+				log.Fatal(err)
+			}
+			return
+		}
+		log.Println(path, "removed")
+	}
+}
+
+func printUsage() {
+	usageText := fmt.Sprintf(`usage: %s [-d directory] [-v] command
+
+Maintain unreleased changelog entries in a modular fashion.
+
+Commands:
+    add [section] [stanza] [message]  Add an entry file. If message is empty, start 
+                                      the editor to edit the message.
+    generate [version]                Generate a changelog in Markdown format and print
+                                      it to STDOUT. version defaults to UNRELEASED.
+    prune                             Delete empty sub-directories recursively.
+
+    Sections             Stanzas
+         ---                 ---
+    breaking                gaia
+    features             gaiacli
+improvements            gaiarest
+    bugfixes                 sdk
+                      tendermint
+`, progName)
+	fmt.Fprintf(os.Stderr, "%s\nFlags:\n", usageText)
+	flag.PrintDefaults()
+}
+
+func errInsufficientArgs() {
+	log.Println("insufficient arguments")
+	printUsage()
+	os.Exit(1)
+}
+
+func errTooManyArgs() {
+	log.Println("too many arguments")
+	printUsage()
+	os.Exit(1)
+}
+
+func unknownCommand(cmd string) {
+	log.Fatalf("unknown command -- '%s'\nTry '%s -help' for more information.", cmd, progName)
+}
+
+// DONTCOVER
diff --git a/contrib/export/lib.py b/contrib/export/lib.py
new file mode 100644
index 000000000..2e7457f75
--- /dev/null
+++ b/contrib/export/lib.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import sys
+
+
+def init_default_argument_parser(prog_desc, default_chain_id, default_start_time):
+    parser = argparse.ArgumentParser(description=prog_desc)
+    parser.add_argument(
+        'exported_genesis',
+        help='exported genesis.json file',
+        type=argparse.FileType('r'), default=sys.stdin,
+    )
+    parser.add_argument('--chain-id', type=str, default=default_chain_id)
+    parser.add_argument('--start-time', type=str, default=default_start_time)
+    return parser
+
+
+def main(argument_parser, process_genesis_func):
+    args = argument_parser.parse_args()
+    if args.chain_id.strip() == '':
+        sys.exit('chain-id required')
+
+    genesis = json.loads(args.exported_genesis.read())
+
+    print(json.dumps(process_genesis_func(
+        genesis=genesis, parsed_args=args,), indent=True))
diff --git a/contrib/export/v0.33.x-to-v0.34.0.py b/contrib/export/v0.33.x-to-v0.34.0.py
new file mode 100755
index 000000000..bb7d6520c
--- /dev/null
+++ b/contrib/export/v0.33.x-to-v0.34.0.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+
+import lib
+
+
+def process_raw_genesis(genesis, parsed_args):
+    # update genesis with breaking changes
+    genesis['consensus_params']['block'] = genesis['consensus_params']['block_size']
+    del genesis['consensus_params']['block_size']
+
+    genesis['app_state']['crisis'] = {
+        'constant_fee': {
+            'amount': '1333000000',  # ~$5,000 worth of uatoms
+            'denom': 'uatom',
+        },
+    }
+
+    # default tm value
+    genesis['consensus_params']['block']['time_iota_ms'] = '1000'
+
+    # proposal #1 updates
+    genesis['app_state']['mint']['params']['blocks_per_year'] = '4855015'
+
+    # proposal #2 updates
+    genesis['consensus_params']['block']['max_gas'] = '2000000'
+    genesis['consensus_params']['block']['max_bytes'] = '200000'
+
+    # enable transfers
+    genesis['app_state']['bank']['send_enabled'] = True
+    genesis['app_state']['distr']['withdraw_addr_enabled'] = True
+
+    # Set new chain ID and genesis start time
+    genesis['chain_id'] = parsed_args.chain_id.strip()
+    genesis['genesis_time'] = parsed_args.start_time
+
+    return genesis
+
+
+if __name__ == '__main__':
+    parser = lib.init_default_argument_parser(
+        prog_desc='Convert genesis.json from v0.33.x to v0.34.0',
+        default_chain_id='cosmoshub-n',
+        default_start_time='2019-02-11T12:00:00Z',
+    )
+    lib.main(parser, process_raw_genesis)
diff --git a/contrib/install-golangci-lint.sh b/contrib/install-golangci-lint.sh
new file mode 100644
index 000000000..9547f7db7
--- /dev/null
+++ b/contrib/install-golangci-lint.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -euo pipefail
+
+installer="$(mktemp)"
+trap "rm -f ${installer}" EXIT
+
+GOBIN="${1}"
+VERSION="${2}"
+HASHSUM="${3}"
+CURL="$(which curl)"
+GOSUM="$(which gosum)"
+
+echo "Downloading golangci-lint ${VERSION} installer ..." >&2
+"${CURL}" -sfL "https://raw.githubusercontent.com/golangci/golangci-lint/${VERSION}/install.sh" > "${installer}"
+
+echo "Checking hashsum ..." >&2
+[ "${HASHSUM}" = "$(${GOSUM} ${installer})" ]
+chmod +x "${installer}"
+
+echo "Launching installer ..." >&2
+exec "${installer}" -d -b "${GOBIN}" "${VERSION}"
diff --git a/crypto/keys/lazy_keybase_test.go b/crypto/keys/lazy_keybase_test.go
new file mode 100644
index 000000000..face5edef
--- /dev/null
+++ b/crypto/keys/lazy_keybase_test.go
@@ -0,0 +1,344 @@
+package keys
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/ed25519"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/hd"
+	"github.com/cosmos/cosmos-sdk/tests"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func TestNew(t *testing.T) {
+	dir, cleanup := tests.NewTestCaseDir(t)
+	defer cleanup()
+	kb := New("keybasename", dir)
+	lazykb, ok := kb.(lazyKeybase)
+	require.True(t, ok)
+	require.Equal(t, lazykb.name, "keybasename")
+	require.Equal(t, lazykb.dir, dir)
+}
+
+func TestLazyKeyManagement(t *testing.T) {
+	dir, cleanup := tests.NewTestCaseDir(t)
+	defer cleanup()
+	kb := New("keybasename", dir)
+
+	algo := Secp256k1
+	n1, n2, n3 := "personal", "business", "other"
+	p1, p2 := "1234", "really-secure!@#$"
+
+	// Check empty state
+	l, err := kb.List()
+	require.Nil(t, err)
+	assert.Empty(t, l)
+
+	_, _, err = kb.CreateMnemonic(n1, English, p1, Ed25519)
+	require.Error(t, err, "ed25519 keys are currently not supported by keybase")
+
+	// create some keys
+	_, err = kb.Get(n1)
+	require.Error(t, err)
+	i, _, err := kb.CreateMnemonic(n1, English, p1, algo)
+
+	require.NoError(t, err)
+	require.Equal(t, n1, i.GetName())
+	_, _, err = kb.CreateMnemonic(n2, English, p2, algo)
+	require.NoError(t, err)
+
+	// we can get these keys
+	i2, err := kb.Get(n2)
+	require.NoError(t, err)
+	_, err = kb.Get(n3)
+	require.NotNil(t, err)
+	_, err = kb.GetByAddress(accAddr(i2))
+	require.NoError(t, err)
+	addr, err := sdk.AccAddressFromBech32("cosmos1yq8lgssgxlx9smjhes6ryjasmqmd3ts2559g0t")
+	require.NoError(t, err)
+	_, err = kb.GetByAddress(addr)
+	require.NotNil(t, err)
+
+	// list shows them in order
+	keyS, err := kb.List()
+	require.NoError(t, err)
+	require.Equal(t, 2, len(keyS))
+	// note these are in alphabetical order
+	require.Equal(t, n2, keyS[0].GetName())
+	require.Equal(t, n1, keyS[1].GetName())
+	require.Equal(t, i2.GetPubKey(), keyS[0].GetPubKey())
+
+	// deleting a key removes it
+	err = kb.Delete("bad name", "foo", false)
+	require.NotNil(t, err)
+	err = kb.Delete(n1, p1, false)
+	require.NoError(t, err)
+	keyS, err = kb.List()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(keyS))
+	_, err = kb.Get(n1)
+	require.Error(t, err)
+
+	// create an offline key
+	o1 := "offline"
+	priv1 := ed25519.GenPrivKey()
+	pub1 := priv1.PubKey()
+	i, err = kb.CreateOffline(o1, pub1)
+	require.Nil(t, err)
+	require.Equal(t, pub1, i.GetPubKey())
+	require.Equal(t, o1, i.GetName())
+	keyS, err = kb.List()
+	require.NoError(t, err)
+	require.Equal(t, 2, len(keyS))
+
+	// delete the offline key
+	err = kb.Delete(o1, "", false)
+	require.NoError(t, err)
+	keyS, err = kb.List()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(keyS))
+
+	// addr cache gets nuked - and test skip flag
+	err = kb.Delete(n2, "", true)
+	require.NoError(t, err)
+}
+
+func TestLazySignVerify(t *testing.T) {
+	dir, cleanup := tests.NewTestCaseDir(t)
+	defer cleanup()
+	kb := New("keybasename", dir)
+	algo := Secp256k1
+
+	n1, n2, n3 := "some dude", "a dudette", "dude-ish"
+	p1, p2, p3 := "1234", "foobar", "foobar"
+
+	// create two users and get their info
+	i1, _, err := kb.CreateMnemonic(n1, English, p1, algo)
+	require.Nil(t, err)
+
+	i2, _, err := kb.CreateMnemonic(n2, English, p2, algo)
+	require.Nil(t, err)
+
+	// Import a public key
+	armor, err := kb.ExportPubKey(n2)
+	require.Nil(t, err)
+	kb.ImportPubKey(n3, armor)
+	i3, err := kb.Get(n3)
+	require.NoError(t, err)
+	require.Equal(t, i3.GetName(), n3)
+
+	// let's try to sign some messages
+	d1 := []byte("my first message")
+	d2 := []byte("some other important info!")
+	d3 := []byte("feels like I forgot something...")
+
+	// try signing both data with both ..
+	s11, pub1, err := kb.Sign(n1, p1, d1)
+	require.Nil(t, err)
+	require.Equal(t, i1.GetPubKey(), pub1)
+
+	s12, pub1, err := kb.Sign(n1, p1, d2)
+	require.Nil(t, err)
+	require.Equal(t, i1.GetPubKey(), pub1)
+
+	s21, pub2, err := kb.Sign(n2, p2, d1)
+	require.Nil(t, err)
+	require.Equal(t, i2.GetPubKey(), pub2)
+
+	s22, pub2, err := kb.Sign(n2, p2, d2)
+	require.Nil(t, err)
+	require.Equal(t, i2.GetPubKey(), pub2)
+
+	// let's try to validate and make sure it only works when everything is proper
+	cases := []struct {
+		key   crypto.PubKey
+		data  []byte
+		sig   []byte
+		valid bool
+	}{
+		// proper matches
+		{i1.GetPubKey(), d1, s11, true},
+		// change data, pubkey, or signature leads to fail
+		{i1.GetPubKey(), d2, s11, false},
+		{i2.GetPubKey(), d1, s11, false},
+		{i1.GetPubKey(), d1, s21, false},
+		// make sure other successes
+		{i1.GetPubKey(), d2, s12, true},
+		{i2.GetPubKey(), d1, s21, true},
+		{i2.GetPubKey(), d2, s22, true},
+	}
+
+	for i, tc := range cases {
+		valid := tc.key.VerifyBytes(tc.data, tc.sig)
+		require.Equal(t, tc.valid, valid, "%d", i)
+	}
+
+	// Now try to sign data with a secret-less key
+	_, _, err = kb.Sign(n3, p3, d3)
+	require.NotNil(t, err)
+}
+
+func TestLazyExportImport(t *testing.T) {
+	dir, cleanup := tests.NewTestCaseDir(t)
+	defer cleanup()
+	kb := New("keybasename", dir)
+
+	info, _, err := kb.CreateMnemonic("john", English, "secretcpw", Secp256k1)
+	require.NoError(t, err)
+	require.Equal(t, info.GetName(), "john")
+
+	john, err := kb.Get("john")
+	require.NoError(t, err)
+	require.Equal(t, info.GetName(), "john")
+	johnAddr := info.GetPubKey().Address()
+
+	armor, err := kb.Export("john")
+	require.NoError(t, err)
+
+	err = kb.Import("john2", armor)
+	require.NoError(t, err)
+
+	john2, err := kb.Get("john2")
+	require.NoError(t, err)
+
+	require.Equal(t, john.GetPubKey().Address(), johnAddr)
+	require.Equal(t, john.GetName(), "john")
+	require.Equal(t, john, john2)
+}
+
+func TestLazyExportImportPubKey(t *testing.T) {
+	dir, cleanup := tests.NewTestCaseDir(t)
+	defer cleanup()
+	kb := New("keybasename", dir)
+
+	// CreateMnemonic a private-public key pair and ensure consistency
+	notPasswd := "n9y25ah7"
+	info, _, err := kb.CreateMnemonic("john", English, notPasswd, Secp256k1)
+	require.Nil(t, err)
+	require.NotEqual(t, info, "")
+	require.Equal(t, info.GetName(), "john")
+	addr := info.GetPubKey().Address()
+	john, err := kb.Get("john")
+	require.NoError(t, err)
+	require.Equal(t, john.GetName(), "john")
+	require.Equal(t, john.GetPubKey().Address(), addr)
+
+	// Export the public key only
+	armor, err := kb.ExportPubKey("john")
+	require.NoError(t, err)
+	// Import it under a different name
+	err = kb.ImportPubKey("john-pubkey-only", armor)
+	require.NoError(t, err)
+	// Ensure consistency
+	john2, err := kb.Get("john-pubkey-only")
+	require.NoError(t, err)
+	// Compare the public keys
+	require.True(t, john.GetPubKey().Equals(john2.GetPubKey()))
+	// Ensure the original key hasn't changed
+	john, err = kb.Get("john")
+	require.NoError(t, err)
+	require.Equal(t, john.GetPubKey().Address(), addr)
+	require.Equal(t, john.GetName(), "john")
+
+	// Ensure keys cannot be overwritten
+	err = kb.ImportPubKey("john-pubkey-only", armor)
+	require.NotNil(t, err)
+}
+
+func TestLazyExportPrivateKeyObject(t *testing.T) {
+	dir, cleanup := tests.NewTestCaseDir(t)
+	defer cleanup()
+	kb := New("keybasename", dir)
+
+	info, _, err := kb.CreateMnemonic("john", English, "secretcpw", Secp256k1)
+	require.NoError(t, err)
+	require.Equal(t, info.GetName(), "john")
+
+	// export private key object
+	_, err = kb.ExportPrivateKeyObject("john", "invalid")
+	require.NotNil(t, err, "%+v", err)
+	exported, err := kb.ExportPrivateKeyObject("john", "secretcpw")
+	require.Nil(t, err, "%+v", err)
+	require.True(t, exported.PubKey().Equals(info.GetPubKey()))
+}
+
+func TestLazyAdvancedKeyManagement(t *testing.T) {
+	dir, cleanup := tests.NewTestCaseDir(t)
+	defer cleanup()
+	kb := New("keybasename", dir)
+
+	algo := Secp256k1
+	n1, n2 := "old-name", "new name"
+	p1, p2 := "1234", "foobar"
+
+	// make sure key works with initial password
+	_, _, err := kb.CreateMnemonic(n1, English, p1, algo)
+	require.Nil(t, err, "%+v", err)
+	assertPassword(t, kb, n1, p1, p2)
+
+	// update password requires the existing password
+	getNewpass := func() (string, error) { return p2, nil }
+	err = kb.Update(n1, "jkkgkg", getNewpass)
+	require.NotNil(t, err)
+	assertPassword(t, kb, n1, p1, p2)
+
+	// then it changes the password when correct
+	err = kb.Update(n1, p1, getNewpass)
+	require.NoError(t, err)
+	// p2 is now the proper one!
+	assertPassword(t, kb, n1, p2, p1)
+
+	// exporting requires the proper name and passphrase
+	_, err = kb.Export(n1 + ".notreal")
+	require.NotNil(t, err)
+	_, err = kb.Export(" " + n1)
+	require.NotNil(t, err)
+	_, err = kb.Export(n1 + " ")
+	require.NotNil(t, err)
+	_, err = kb.Export("")
+	require.NotNil(t, err)
+	exported, err := kb.Export(n1)
+	require.Nil(t, err, "%+v", err)
+
+	// import succeeds
+	err = kb.Import(n2, exported)
+	require.NoError(t, err)
+
+	// second import fails
+	err = kb.Import(n2, exported)
+	require.NotNil(t, err)
+}
+
+// TestSeedPhrase verifies restoring from a seed phrase
+func TestLazySeedPhrase(t *testing.T) {
+	dir, cleanup := tests.NewTestCaseDir(t)
+	defer cleanup()
+	kb := New("keybasename", dir)
+
+	algo := Secp256k1
+	n1, n2 := "lost-key", "found-again"
+	p1, p2 := "1234", "foobar"
+
+	// make sure key works with initial password
+	info, mnemonic, err := kb.CreateMnemonic(n1, English, p1, algo)
+	require.Nil(t, err, "%+v", err)
+	require.Equal(t, n1, info.GetName())
+	assert.NotEmpty(t, mnemonic)
+
+	// now, let us delete this key
+	err = kb.Delete(n1, p1, false)
+	require.Nil(t, err, "%+v", err)
+	_, err = kb.Get(n1)
+	require.NotNil(t, err)
+
+	// let us re-create it from the mnemonic-phrase
+	params := *hd.NewFundraiserParams(0, 0)
+	newInfo, err := kb.Derive(n2, mnemonic, DefaultBIP39Passphrase, p2, params)
+	require.NoError(t, err)
+	require.Equal(t, n2, newInfo.GetName())
+	require.Equal(t, info.GetPubKey().Address(), newInfo.GetPubKey().Address())
+	require.Equal(t, info.GetPubKey(), newInfo.GetPubKey())
+}
diff --git a/crypto/keys/mintkey/mintkey_test.go b/crypto/keys/mintkey/mintkey_test.go
new file mode 100644
index 000000000..86df52366
--- /dev/null
+++ b/crypto/keys/mintkey/mintkey_test.go
@@ -0,0 +1,36 @@
+package mintkey_test
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/mintkey"
+	"github.com/stretchr/testify/require"
+	cryptoAmino "github.com/tendermint/tendermint/crypto/encoding/amino"
+	"github.com/tendermint/tendermint/crypto/secp256k1"
+)
+
+func TestArmorUnarmorPrivKey(t *testing.T) {
+	priv := secp256k1.GenPrivKey()
+	armor := mintkey.EncryptArmorPrivKey(priv, "passphrase")
+	_, err := mintkey.UnarmorDecryptPrivKey(armor, "wrongpassphrase")
+	require.Error(t, err)
+	decrypted, err := mintkey.UnarmorDecryptPrivKey(armor, "passphrase")
+	require.NoError(t, err)
+	require.True(t, priv.Equals(decrypted))
+}
+
+func TestArmorUnarmorPubKey(t *testing.T) {
+	// Select the encryption and storage for your cryptostore
+	cstore := keys.NewInMemory()
+
+	// Add keys and see they return in alphabetical order
+	info, _, err := cstore.CreateMnemonic("Bob", keys.English, "passphrase", keys.Secp256k1)
+	require.NoError(t, err)
+	armor := mintkey.ArmorPubKeyBytes(info.GetPubKey().Bytes())
+	pubBytes, err := mintkey.UnarmorPubKeyBytes(armor)
+	require.NoError(t, err)
+	pub, err := cryptoAmino.PubKeyFromBytes(pubBytes)
+	require.NoError(t, err)
+	require.True(t, pub.Equals(info.GetPubKey()))
+}
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index e8ee111d6..52dfd3a2b 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -34,21 +34,22 @@ module.exports = {
         ]
       },
       {
-        title: "Gaia",
+        title: "Cosmos Hub",
         collapsable: true,
         children: [
-          "/gaia/what-is-gaia",
-          "/gaia/installation",
-          "/gaia/join-mainnet",
-          "/gaia/validators/validator-setup",
-          "/gaia/validators/overview",
-          "/gaia/validators/security",
-          "/gaia/validators/validator-faq",
-          "/gaia/delegator-guide-cli",
-          "/gaia/ledger",
-          "/gaia/gaiacli",
-          "/gaia/join-testnet",
-          "/gaia/deploy-testnet"
+          "/cosmos-hub/what-is-gaia",
+          "/cosmos-hub/installation",
+          "/cosmos-hub/join-mainnet",
+          "/cosmos-hub/validators/validator-setup",
+          "/cosmos-hub/validators/overview",
+          "/cosmos-hub/validators/security",
+          "/cosmos-hub/validators/validator-faq",
+          "/cosmos-hub/delegator-guide-cli",
+          "/cosmos-hub/genesis",
+          "/cosmos-hub/ledger",
+          "/cosmos-hub/gaiacli",
+          "/cosmos-hub/join-testnet",
+          "/cosmos-hub/deploy-testnet"
         ]
       },
       {
diff --git a/docs/DOCS_README.md b/docs/DOCS_README.md
index 5870d3e27..e858e4e73 100644
--- a/docs/DOCS_README.md
+++ b/docs/DOCS_README.md
@@ -95,7 +95,7 @@ then navigate to localhost:8080 in your browser.
 
 ## Build RPC Docs
 
-First, run `make get_tools` from the root of repo, to install the swagger-ui tool.
+First, run `make tools` from the root of repo, to install the swagger-ui tool.
 
 Then, edit the `swagger.yaml` manually; it is found [here](https://github.com/cosmos/cosmos-sdk/blob/develop/client/lcd/swagger-ui/swagger.yaml)
 
diff --git a/docs/_attic/WIP-lamborghini-distribution/transactions.md b/docs/_attic/WIP-lamborghini-distribution/transactions.md
index 085f3b6e3..b02141185 100644
--- a/docs/_attic/WIP-lamborghini-distribution/transactions.md
+++ b/docs/_attic/WIP-lamborghini-distribution/transactions.md
@@ -76,7 +76,7 @@ When a validator wishes to withdraw their transaction fees it must send
 triggered each with any change in individual delegations, such as an unbond,
 redelegation, or delegation of additional tokens to a specific validator. This
 transaction withdraws the validators commission rewards, as well as any rewards
-earning on their self-delegation. 
+earning on their self-delegation.
 
 ```golang
 type TxWithdrawValidator struct {
diff --git a/docs/_attic/sdk/core/app1.md b/docs/_attic/sdk/core/app1.md
index 4b2257b3c..88e75e17b 100644
--- a/docs/_attic/sdk/core/app1.md
+++ b/docs/_attic/sdk/core/app1.md
@@ -153,11 +153,11 @@ Along with the message, the Handler takes environmental information (a `Context`
 All information necessary for processing a message should be available in the context.
 
 Where is the KVStore in all of this? Access to the KVStore in a message handler is restricted by the Context via object-capability keys.
-Only handlers which were given explict access to a store's key will be able to access that store during message processsing.
+Only handlers which were given explicit access to a store's key will be able to access that store during message processsing.
 
 ### Context
 
-The SDK uses a `Context` to propogate common information across functions.
+The SDK uses a `Context` to propagate common information across functions.
 Most importantly, the `Context` restricts access to KVStores based on object-capability keys.
 Only handlers which have been given explicit access to a key will be able to access the corresponding store.
 
@@ -176,7 +176,7 @@ func newFooHandler(key sdk.StoreKey) sdk.Handler {
 `Context` is modeled after the Golang
 [context.Context](https://golang.org/pkg/context/), which has
 become ubiquitous in networking middleware and routing applications as a means
-to easily propogate request context through handler functions.
+to easily propagate request context through handler functions.
 Many methods on SDK objects receive a context as the first argument.
 
 The Context also contains the
diff --git a/docs/clients/lite/getting_started.md b/docs/clients/lite/getting_started.md
index 47ee16f9e..7f5099402 100644
--- a/docs/clients/lite/getting_started.md
+++ b/docs/clients/lite/getting_started.md
@@ -19,18 +19,4 @@ gaiacli rest-server --chain-id=test \
     --trust-node=false
 ```
 
-The server listens on HTTP by default. You can enable the secure layer by adding the `--tls` flag.
-By default a self-signed certificate will be generated and its fingerprint printed out. You can
-configure the server to use a SSL certificate by passing the certificate and key files via the
-`--ssl-certfile` and `--ssl-keyfile` flags:
-
-```bash
-gaiacli rest-server --chain-id=test \
-    --laddr=tcp://localhost:1317 \
-    --node tcp://localhost:26657 \
-    --trust-node=false \
-    --tls \
-    --ssl-certfile=mycert.pem --ssl-keyfile=mykey.key
-```
-
 For more information about the Gaia-Lite RPC, see the [swagger documentation](https://cosmos.network/rpc/)
diff --git a/docs/clients/service-providers.md b/docs/clients/service-providers.md
index 68024d641..b563153f1 100644
--- a/docs/clients/service-providers.md
+++ b/docs/clients/service-providers.md
@@ -121,3 +121,69 @@ mechanism for instance.
 In order to generate an unsigned transaction (example with
 [coin transfer](https://cosmos.network/rpc/#/ICS20/post_bank_accounts__address__transfers)),
 you need to use the field `generate_only` in the body of `base_req`.
+
+## Cosmos SDK Transaction Signing
+
+Cosmos SDK transaction signing is a fairly simple process.
+
+Every Cosmos SDK transaction has a canonical JSON representation. The `gaiacli`
+and Stargate REST interfaces provide canonical JSON representations of transactions
+and their "broadcast" functions will provide compact Amino (a protobuf-like wire format)
+encoding translations.
+
+Things to know when signing messages:
+
+The format is as follows
+
+```json
+{
+  "account_number": XXX,
+  "chain_id": XXX,
+  "fee": XXX,
+  "sequence": XXX,
+  "memo": XXX,
+  "msgs": XXX
+}
+```
+
+The signer must supply `"chain_id"`, `"account number"` and `"sequence number"`.
+
+The `"fee"`, `"msgs"` and `"memo"` fields will be supplied by the transaction
+composer interface.
+
+The `"account_number"` and `"sequence"` fields can be queried directly from the
+blockchain or cached locally. Getting these numbers wrong, along with the chainID,
+is a common cause of invalid signature error. You can load the mempool of a full
+node or validator with a sequence of uncommitted transactions with incrementing
+sequence numbers and it will mostly do the correct thing.  
+
+Before signing, all keys are lexicographically sorted and all white space is
+removed from the JSON output.
+
+The signature encoding is the 64-byte concatenation of ECDSArands (i.e. `r || s`),
+where `s` is lexicographically less than its inverse in order to prevent malleability.
+This is like Ethereum, but without the extra byte for PubKey recovery, since
+Tendermint assumes the PubKey is always provided anyway.
+
+Signatures and public key examples in a signed transaction:
+
+``` json
+{
+  "type": "auth/StdTx",
+  "value": {
+    "msg": [...],
+    "signatures": [
+      {
+        "pub_key": {
+          "type": "tendermint/PubKeySecp256k1",
+          "value": XXX
+        },
+        "signature": XXX
+      }
+    ],
+  }
+}
+```
+
+Once signatures are properly generated, insert the JSON into into the generated
+transaction and then use the broadcast endpoint.
diff --git a/docs/gaia/README.md b/docs/cosmos-hub/README.md
similarity index 73%
rename from docs/gaia/README.md
rename to docs/cosmos-hub/README.md
index eaf21a823..75a9b31f4 100644
--- a/docs/gaia/README.md
+++ b/docs/cosmos-hub/README.md
@@ -1,6 +1,6 @@
-# Gaia Documentation
+# Cosmos Hub Documentation
 
-Welcome to the `Gaia` docs. `Gaia` is the current name of the Cosmos SDK application for the Cosmos Hub.
+Welcome to the documentation of the **Cosmos Hub application: `gaia`**.
 
 ## Join the Cosmos Hub Mainnet
 
@@ -12,11 +12,11 @@ Welcome to the `Gaia` docs. `Gaia` is the current name of the Cosmos SDK applica
 
 - [Join the testnet](./join-testnet.md)
 
-## Setup your own `gaia` testnet
+## Setup Your Own `gaia` Testnet
 
 - [Setup your own `gaia` testnet](./deploy-testnet.md)
 
-## Additional resources
+## Additional Resources
 
 - [Intro to validators](./validators/overview.md)
 - [Validator FAQ](./validators/validator-faq.md)
diff --git a/docs/gaia/delegator-guide-cli.md b/docs/cosmos-hub/delegator-guide-cli.md
similarity index 92%
rename from docs/gaia/delegator-guide-cli.md
rename to docs/cosmos-hub/delegator-guide-cli.md
index a77914c1e..aab15da88 100644
--- a/docs/gaia/delegator-guide-cli.md
+++ b/docs/cosmos-hub/delegator-guide-cli.md
@@ -27,22 +27,22 @@ of any kind.
 
 Please exercise extreme caution!
 
-## Table of contents
+## Table of Contents
 
 - [Installing `gaiacli`](#installing-gaiacli)
 - [Cosmos Accounts](#cosmos-accounts)
-    + [Restoring an account from the fundrasier](#restoring-an-account-from-the-fundraiser)
-    + [Creating an account](#creating-an-account)
-- [Accessing the Cosmos Hub network](#accessing-the-cosmos-hub-network)
-    + [Running your own full-node](#running-your-own-full-node)
-    + [Connecting to a remote full-node](#connecting-to-a-remote-full-node)
-- [Setting up `gaiacli`](#setting-up-gaiacli)
-- [Querying the state](#querying-the-state)
+    + [Restoring an Account from the Fundraiser](#restoring-an-account-from-the-fundraiser)
+    + [Creating an Account](#creating-an-account)
+- [Accessing the Cosmos Hub Network](#accessing-the-cosmos-hub-network)
+    + [Running Your Own Full-Node](#running-your-own-full-node)
+    + [Connecting to a Remote Full-Node](#connecting-to-a-remote-full-node)
+- [Setting Up `gaiacli`](#setting-up-gaiacli)
+- [Querying the State](#querying-the-state)
 - [Sending Transactions](#sending-transactions)
-    + [A note on gas and fees](#a-note-on-gas-and-fees)
-    + [Bonding Atoms and Withdrawing rewards](#bonding-atoms-and-withdrawing-rewards)
+    + [A Note on Gas and Fees](#a-note-on-gas-and-fees)
+    + [Bonding Atoms and Withdrawing Rewards](#bonding-atoms-and-withdrawing-rewards)
     + [Participating in Governance](#participating-in-governance)
-    + [Signing transactions from an offline computer](#signing-transactions-from-an-offline-computer)
+    + [Signing Transactions from an Offline Computer](#signing-transactions-from-an-offline-computer)
 
 ## Installing `gaiacli` 
 
@@ -109,7 +109,7 @@ The funds stored in an account are controlled by the private key. This private k
 
 The address is a public string with a human-readable prefix (e.g. `cosmos10snjt8dmpr5my0h76xj48ty80uzwhraqalu4eg`) that identifies your account. When someone wants to send you funds, they send it to your address. It is computationally infeasible to find the private key associated with a given address. 
 
-### Restoring an account from the fundraiser
+### Restoring an Account from the Fundraiser
 
 ::: tip
 *NOTE: This section only concerns fundraiser participants*
@@ -117,7 +117,7 @@ The address is a public string with a human-readable prefix (e.g. `cosmos10snjt8
 
 If you participated in the fundraiser, you should be in possession of a 12-words mnemonic. Newly generated mnemonics use 24 words, but 12-word mnemonics are also compatible with all the Cosmos tools. 
 
-#### On a ledger device
+#### On a Ledger Device
 
 At the core of a ledger device, there is a mnemonic used to generate accounts on multiple blockchains (including the Cosmos Hub). Usually, you will create a new mnemonic when you initialize your ledger device. However, it is possible to tell the ledger device to use a mnemonic provided by the user instead. Let us go ahead and see how you can input the mnemonic you obtained during the fundraiser as the seed of your ledger device. 
 
@@ -138,7 +138,7 @@ Your ledger is now correctly set up with your fundraiser mnemonic! Do not lose t
 
 Next, click [here](#using-a-ledger-device) to learn how to generate an account. 
 
-#### On a computer
+#### On a Computer
 
 ::: warning
 **NOTE: It is more secure to perform this action on an offline computer**
@@ -155,11 +155,11 @@ You will be prompted to input a passphrase that is used to encrypt the private k
 - `<yourKeyName>` is the name of the account. It is a reference to the account number used to derive the key pair from the mnemonic. You will use this name to identify your account when you want to send a transaction.
 - You can add the optional `--account` flag to specify the path (`0`, `1`, `2`, ...) you want to use to generate your account. By default, account `0` is generated. 
 
-### Creating an account
+### Creating an Account
 
-To create an account, you just need to have `gaiacli` installed. Before creating it, you need to know where you intend to store and interract with your private keys. The best options are to store them in an offline dedicated computer or a ledger device. Storing them on your regular online computer involves more risk, since anyone who infiltrates your computer through the internet could exfiltrate your private keys and steal your funds.
+To create an account, you just need to have `gaiacli` installed. Before creating it, you need to know where you intend to store and interact with your private keys. The best options are to store them in an offline dedicated computer or a ledger device. Storing them on your regular online computer involves more risk, since anyone who infiltrates your computer through the internet could exfiltrate your private keys and steal your funds.
 
-#### Using a ledger device
+#### Using a Ledger Device
 
 ::: warning
 **Only use Ledger devices that you bought factory new or trust fully**
@@ -185,7 +185,7 @@ gaiacli keys add <yourAccountName> --ledger
 - `<yourKeyName>` is the name of the account. It is a reference to the account number used to derive the key pair from the mnemonic. You will use this name to identify your account when you want to send a transaction.
 - You can add the optional `--account` flag to specify the path (`0`, `1`, `2`, ...) you want to use to generate your account. By default, account `0` is generated. 
 
-#### Using a computer 
+#### Using a Computer 
 
 ::: warning
 **NOTE: It is more secure to perform this action on an offline computer**
@@ -225,7 +225,7 @@ gaiacli keys add <yourKeyName> --recover --account 1
 This command will prompt you to input a passphrase as well as your mnemonic. Change the account number to generate a different account. 
 
 
-## Accessing the Cosmos Hub network
+## Accessing the Cosmos Hub Network
 
 In order to query the state and send transactions, you need a way to access the network. To do so, you can either run your own full-node, or connect to someone else's.
 
@@ -233,19 +233,19 @@ In order to query the state and send transactions, you need a way to access the
 **NOTE: Do not share your mnemonic (12 or 24 words) with anyone. The only person who should ever need to know it is you. This is especially important if you are ever approached via email or direct message by someone requesting that you share your mnemonic for any kind of blockchain services or support. No one from Cosmos, the Tendermint team or the Interchain Foundation will ever send an email that asks for you to share any kind of account credentials or your mnemonic."**.
 ::: 
 
-### Running your own full-node
+### Running Your Own Full-Node
 
 This is the most secure option, but comes with relatively high resource requirements. In order to run your own full-node, you need good bandwidth and at least 1TB of disk space. 
 
 You will find the tutorial on how to install `gaiad` [here](https://cosmos.network/docs/gaia/installation.html), and the guide to run a full-node [here](https://cosmos.network/docs/gaia/join-mainnet.html).
 
-### Connecting to a remote full-node
+### Connecting to a Remote Full-Node
 
 If you do not want or cannot run your own node, you can connect to someone else's full-node. You should pick an operator you trust, because a malicious operator could return  incorrect query results or censor your transactions. However, they will never be able to steal your funds, as your private keys are stored locally on your computer or ledger device. Possible options of full-node operators include validators, wallet providers or exchanges. 
 
 In order to connect to the full-node, you will need an address of the following form: `https://77.87.106.33:26657` (*Note: This is a placeholder*). This address has to be communicated by the full-node operator you choose to trust. You will use this address in the [following section](#setting-up-gaiacli).
 
-## Setting up `gaiacli`
+## Setting Up `gaiacli`
 
 ::: tip
 **Before setting up `gaiacli`, make sure you have set up a way to [access the Cosmos Hub network](#accessing-the-cosmos-hub-network)**
@@ -289,7 +289,7 @@ Finally, let us set the `chain-id` of the blockchain we want to interact with:
 gaiacli config chain-id cosmoshub-1
 ```
 
-## Querying the state
+## Querying the State
 
 ::: tip
 **Before you can bond atoms and withdraw rewards, you need to [set up `gaiacli`](#setting-up-gaiacli)**
@@ -337,10 +337,10 @@ For each command, you can use the `-h` or `--help` flag to get more information.
 ## Sending Transactions
 
 ::: warning
-On Cosmos Hub mainnet, the accepted denom is `uatom` (micro-Atom), where `1atom = 1,000,000uatom`
+On Cosmos Hub mainnet, the accepted denom is `uatom`, where `1atom = 1,000,000uatom`
 :::
 
-### A note on gas and fees
+### A Note on Gas and Fees
 
 Transactions on the Cosmos Hub network need to include a transaction fee in order to be processed. This fee pays for the gas required to run the transaction. The formula is the following:
 
@@ -358,14 +358,14 @@ The transaction `fees` are the product of `gas` and `gasPrice`. As a user, you h
 For mainnet, the recommended `gas-prices` is `0.025uatom`. 
 ::: 
 
-### Bonding Atoms and Withdrawing rewards
+### Bonding Atoms and Withdrawing Rewards
 
 ::: tip
 **Before you can bond atoms and withdraw rewards, you need to [set up `gaiacli`](#setting-up-gaiacli) and [create an account](#creating-an-account)**
 :::
 
 ::: warning
-**Before bonding Atoms, please read the [delegator faq](https://cosmos.network/resources/delegators) to understand the risk and responsabilities involved with delegating**
+**Before bonding Atoms, please read the [delegator faq](https://cosmos.network/resources/delegators) to understand the risk and responsibilities involved with delegating**
 :::
 
 ::: warning
@@ -379,6 +379,14 @@ For mainnet, the recommended `gas-prices` is `0.025uatom`.
 gaiacli tx staking delegate <validatorAddress> <amountToBond> --from <delegatorKeyName> --gas auto --gas-adjustment 1.5 --gas-prices <gasPrice>
 
 
+// Redelegate a certain amount of Atoms from a validator to another
+// Can only be used if already bonded to a validator
+// Redelegation takes effect immediately, there is no waiting period to redelegate
+// After a redelegation, no other redelegation can be made from the account for the next 3 weeks
+// ex value for flags: <stcValidatorAddress>=cosmosvaloper18thamkhnj9wz8pa4nhnp9rldprgant57pk2m8s, <amountToRedelegate>=100000000uatom, <gasPrice>=0.025uatom
+
+gaiacli tx staking redelegate <srcValidatorAddress> <destValidatorAddress> <amountToRedelegate> --from <delegatorKeyName> --gas auto --gas-adjustment 1.5 --gas-prices <gasPrice>
+
 // Withdraw all rewards
 // ex value for flag: <gasPrice>=0.025uatom
 
@@ -413,9 +421,9 @@ gaiacli query tx <txHash>
 
 Double check with a block explorer if you interact with the network through a trusted full-node. 
 
-## Participating in governance
+## Participating in Governance
 
-#### Primer on governance
+#### Primer on Governance
 
 The Cosmos Hub has a built-in governance system that lets bonded Atom holders vote on proposals. There are three types of proposal:
 
@@ -429,7 +437,7 @@ Once the `deposit` reaches `minDeposit`, the proposal enters the `voting_period`
 
 At the end of the voting period, the proposal is accepted if there are more than 50% `Yes` votes (excluding `Abstain ` votes) and less than 33.33% of `NoWithVeto` votes (excluding `Abstain` votes).
 
-#### In practice
+#### In Practice
 
 ::: tip
 **Before you can bond atoms and withdraw rewards, you need to [bond Atoms](#bonding-atoms-and-withdrawing-rewards)**
@@ -459,7 +467,7 @@ gaiacli tx gov deposit <proposalID> <deposit> --gas auto --gas-adjustment 1.5 --
 gaiacli tx gov vote <proposalID> <option> --gas auto --gas-adjustment 1.5 --gas-prices <gasPrice> --from <delegatorKeyName>
 ```
 
-### Signing transactions from an offline computer
+### Signing Transactions From an Offline Computer
 
 If you do not have a ledger device and want to interact with your private key on an offline computer, you can use the following procedure. First, generate an unsigned transaction on an **online computer** with the following command (example with a bonding transaction):
 
diff --git a/docs/gaia/deploy-testnet.md b/docs/cosmos-hub/deploy-testnet.md
similarity index 96%
rename from docs/gaia/deploy-testnet.md
rename to docs/cosmos-hub/deploy-testnet.md
index 2aa2f692e..0757d6581 100644
--- a/docs/gaia/deploy-testnet.md
+++ b/docs/cosmos-hub/deploy-testnet.md
@@ -1,4 +1,4 @@
-# Deploy your own testnet
+# Deploy Your Own Testnet
 
 This document describes 3 ways to setup a network of `gaiad` nodes, each serving a different usecase:
 
@@ -20,7 +20,7 @@ In case you need to use or deploy gaia as a container you could skip the `build`
 
 The same images can be used to build your own docker-compose stack.
 
-## Single-node, local, manual testnet
+## Single-node, Local, Manual Testnet
 
 This guide helps you create a single validator node that runs a network locally for testing and other development related uses.
 
@@ -29,7 +29,7 @@ This guide helps you create a single validator node that runs a network locally
 - [Install gaia](./installation.md)
 - [Install `jq`](https://stedolan.github.io/jq/download/) (optional)
 
-### Create genesis file and start the network
+### Create Genesis File and Start the Network
 
 ```bash
 # You can run all of these commands from your home directory
@@ -58,7 +58,7 @@ gaiad start
 
 This setup puts all the data for `gaiad` in `~/.gaiad`. You can examine the genesis file you created at `~/.gaiad/config/genesis.json`. With this configuration `gaiacli` is also ready to use and has an account with tokens (both staking and custom).
 
-## Multi-node, local, automated testnet
+## Multi-node, Local, Automated Testnet
 
 From the [networks/local directory](https://github.com/cosmos/cosmos-sdk/tree/develop/networks/local):
 
@@ -83,7 +83,7 @@ make build-linux
 make build-docker-gaiadnode
 ```
 
-### Run your testnet
+### Run Your Testnet
 
 To start a 4 node testnet run:
 
@@ -181,7 +181,7 @@ funds!
 **Note**: Each node's seed is located at `./build/nodeN/gaiacli/key_seed.json` and can be restored to the CLI using the `gaiacli keys add --restore` command
 :::
 
-### Special binaries
+### Special Binaries
 
 If you have multiple binaries with different names, you can specify which one to run with the BINARY environment variable. The path of the binary is relative to the attached volume. For example:
 
@@ -190,7 +190,7 @@ If you have multiple binaries with different names, you can specify which one to
 BINARY=gaiafoo make localnet-start
 ```
 
-## Multi-node, remote, automated testnet
+## Multi-Node, Remote, Automated Testnet
 
 The following should be run from the [networks directory](https://github.com/cosmos/cosmos-sdk/tree/develop/networks).
 
@@ -216,7 +216,7 @@ export SSH_PUBLIC_FILE="$HOME/.ssh/id_rsa.pub"
 
 These will be used by both `terraform` and `ansible`.
 
-### Create a remote network
+### Create a Remote Network
 
 ```
 SERVERS=1 REGION_LIMIT=1 make validators-start
@@ -228,13 +228,13 @@ The testnet name is what's going to be used in --chain-id, while the cluster nam
 ./new-testnet.sh "$TESTNET_NAME" "$CLUSTER_NAME" 1 1
 ```
 
-### Quickly see the /status endpoint
+### Quickly see the /status Endpoint
 
 ```
 make validators-status
 ```
 
-### Delete servers
+### Delete Servers
 
 ```
 make validators-stop
diff --git a/docs/gaia/gaiacli.md b/docs/cosmos-hub/gaiacli.md
similarity index 92%
rename from docs/gaia/gaiacli.md
rename to docs/cosmos-hub/gaiacli.md
index dbbc05ebe..509745551 100644
--- a/docs/gaia/gaiacli.md
+++ b/docs/cosmos-hub/gaiacli.md
@@ -1,4 +1,4 @@
-# Gaia client
+# Gaia Client
 
 ## Gaia CLI
 
@@ -97,7 +97,7 @@ Note that this is the Tendermint signing key, _not_ the operator key you will us
 We strongly recommend _NOT_ using the same passphrase for multiple keys. The Tendermint team and the Interchain Foundation will not be responsible for the loss of funds.
 :::
 
-#### Generate multisig public keys
+#### Generate Multisig Public Keys
 
 You can generate and print a multisig public key by typing:
 
@@ -128,6 +128,19 @@ gaiacli keys show --multisig-threshold K name1 name2 name3 [...]
 For more information regarding how to generate, sign and broadcast transactions with a
 multi signature account see [Multisig Transactions](#multisig-transactions).
 
+### Tx Broadcasting
+
+When broadcasting transactions, `gaiacli` accepts a `--broadcast-mode` flag. This
+flag can have a value of `sync` (default), `async`, or `block`, where `sync` makes
+the client return a CheckTx response, `async` makes the client return immediately,
+and `block` makes the client wait for the tx to be committed (or timing out).
+
+It is important to note that the `block` mode should **not** be used in most
+circumstances. This is because broadcasting can timeout but the tx may still be
+included in a block. This can result in many undesirable situations. Therefor, it
+is best to use `sync` or `async` and query by tx hash to determine when the tx
+is included in a block.
+
 ### Fees & Gas
 
 Each transaction may either supply fees or gas prices, but not both. 
@@ -156,7 +169,7 @@ gaiacli tx send ... --gas-prices=0.025uatom
 
 The best way to get tokens is from the [Cosmos Testnet Faucet](https://faucetcosmos.network). If the faucet is not working for you, try asking [#cosmos-validators](https://riot.im/app/#/room/#cosmos-validators:matrix.org). The faucet needs the `cosmos` from the account you wish to use for staking.
 
-#### Query Account balance
+#### Query Account Balance
 
 After receiving tokens to your address, you can view your account's balance by typing:
 
@@ -243,7 +256,7 @@ gaiacli tx broadcast --node=<node> signedSendTx.json
 
 ### Query Transactions
 
-#### Matching a set of tags
+#### Matching a Set of Tags
 
 You can use the transaction search command to query for transactions that match a specific set of `tags`, which are added on every transaction.
 
@@ -280,7 +293,7 @@ You can find a list of available `tags` on each of the SDK modules:
 - [Bank tags](https://github.com/cosmos/cosmos-sdk/blob/d1e76221d8e28824bb4791cb4ad8662d2ae9051e/x/bank/keeper.go#L193-L206)
 :::
 
-#### Matching a transaction's hash
+#### Matching a Transaction's Hash
 
 You can also query a single transaction by its hash using the following command:
 
@@ -314,6 +327,26 @@ You can get the current slashing parameters via:
 gaiacli query slashing params
 ```
 
+### Minting
+
+You can query for the minting/inflation parameters via:
+
+```bash
+gaiacli query minting params
+```
+
+To query for the current inflation value:
+
+```bash
+gaiacli query minting inflation
+```
+
+To query for the current annual provisions value:
+
+```bash
+gaiacli query minting annual-provisions
+```
+
 ### Staking
 
 #### Set up a Validator
@@ -374,16 +407,15 @@ Or if you want to check all your current delegations with disctinct validators:
 gaiacli query staking delegations <delegator_addr>
 ```
 
-You can also get previous delegation(s) status by adding the `--height` flag.
-
 #### Unbond Tokens
 
-If for any reason the validator misbehaves, or you just want to unbond a certain amount of tokens, use this following command. You can unbond a specific `shares-amount` (eg:`12.1`\) or a `shares-fraction` (eg:`0.25`) with the corresponding flags.
+If for any reason the validator misbehaves, or you just want to unbond a certain
+amount of tokens, use this following command.
 
 ```bash
 gaiacli tx staking unbond \
-  --validator=<account_cosmosval> \
-  --shares-fraction=0.5 \
+  <validator_addr> \
+  10atom \
   --from=<key_name> \
   --chain-id=<chain_id>
 ```
@@ -410,17 +442,15 @@ Additionally, as you can get all the unbonding-delegations from a particular val
 gaiacli query staking unbonding-delegations-from <account_cosmosval>
 ```
 
-To get previous unbonding-delegation(s) status on past blocks, try adding the `--height` flag.
-
 #### Redelegate Tokens
 
 A redelegation is a type delegation that allows you to bond illiquid tokens from one validator to another:
 
 ```bash
 gaiacli tx staking redelegate \
-  --addr-validator-source=<account_cosmosval> \
-  --addr-validator-dest=<account_cosmosval> \
-  --shares-fraction=50 \
+  <src-validator-operator-addr> \
+  <dst-validator-operator-addr> \
+  10atom \
   --from=<key_name> \
   --chain-id=<chain_id>
 ```
@@ -437,7 +467,7 @@ Once you begin an redelegation, you can see it's information by using the follow
 gaiacli query staking redelegation <delegator_addr> <src_val_addr> <dst_val_addr>
 ```
 
-Or if you want to check all your current unbonding-delegations with disctinct validators:
+Or if you want to check all your current unbonding-delegations with distinct validators:
 
 ```bash
 gaiacli query staking redelegations <account_cosmos>
@@ -449,8 +479,6 @@ Additionally, as you can get all the outgoing redelegations from a particular va
   gaiacli query staking redelegations-from <account_cosmosval>
 ```
 
-To get previous redelegation(s) status on past blocks, try adding the `--height` flag.
-
 #### Query Parameters
 
 Parameters define high level settings for staking. You can get the current values by using:
@@ -505,7 +533,7 @@ Some considerations about the voting process:
 
 For more information about the governance process and how it works, please check out the Governance module [specification](./../spec/governance).
 
-#### Create a Governance proposal
+#### Create a Governance Proposal
 
 In order to create a governance proposal, you must submit an initial deposit along with the proposal details:
 
@@ -523,7 +551,7 @@ gaiacli tx gov submit-proposal \
   --chain-id=<chain_id>
 ```
 
-##### Query proposals
+##### Query Proposals
 
 Once created, you can now query information of the proposal:
 
@@ -545,7 +573,7 @@ To query for the proposer of a given governance proposal:
 gaiacli query gov proposer <proposal_id>
 ```
 
-#### Increase deposit
+#### Increase Deposit
 
 In order for a proposal to be broadcasted to the network, the amount deposited must be above a `minDeposit` value (initial value: `512000000uatom`). If the proposal you previously created didn't meet this requirement, you can still increase the total amount deposited to activate it. Once the minimum deposit is reached, the proposal enters voting period:
 
@@ -557,7 +585,7 @@ gaiacli tx gov deposit <proposal_id> "10000000uatom" \
 
 > _NOTE_: Proposals that don't meet this requirement will be deleted after `MaxDepositPeriod` is reached.
 
-##### Query deposits
+##### Query Deposits
 
 Once a new proposal is created, you can query all the deposits submitted to it:
 
@@ -571,7 +599,7 @@ You can also query a deposit submitted by a specific address:
 gaiacli query gov deposit <proposal_id> <depositor_address>
 ```
 
-#### Vote on a proposal
+#### Vote on a Proposal
 
 After a proposal's deposit reaches the `MinDeposit` value, the voting period opens. Bonded `Atom` holders can then cast vote on it:
 
@@ -581,7 +609,7 @@ gaiacli tx gov vote <proposal_id> <Yes/No/NoWithVeto/Abstain> \
   --chain-id=<chain_id>
 ```
 
-##### Query votes
+##### Query Votes
 
 Check the vote with the option you just submitted:
 
@@ -603,7 +631,7 @@ To check the current tally of a given proposal you can use the `tally` command:
 gaiacli query gov tally <proposal_id>
 ```
 
-#### Query governance parameters
+#### Query Governance Parameters
 
 To check the current governance parameters run:
 
@@ -621,7 +649,7 @@ gaiacli query gov param deposit
 
 ### Fee Distribution
 
-#### Query distribution parameters
+#### Query Distribution Parameters
 
 To check the current distribution parameters, run:
 
@@ -629,6 +657,14 @@ To check the current distribution parameters, run:
 gaiacli query distr params
 ```
 
+#### Query distribution Community Pool
+
+To query all coins in the community pool which is under Governance control:
+
+```bash
+gaiacli query distr community-pool
+```
+
 #### Query outstanding rewards
 
 To check the current outstanding (un-withdrawn) rewards, run:
@@ -637,7 +673,7 @@ To check the current outstanding (un-withdrawn) rewards, run:
 gaiacli query distr outstanding-rewards
 ```
 
-#### Query validator commission
+#### Query Validator Commission
 
 To check the current outstanding commission for a validator, run:
 
@@ -645,7 +681,7 @@ To check the current outstanding commission for a validator, run:
 gaiacli query distr commission <validator_address>
 ```
 
-#### Query validator slashes
+#### Query Validator Slashes
 
 To check historical slashes for a validator, run:
 
@@ -653,7 +689,7 @@ To check historical slashes for a validator, run:
 gaiacli query distr slashes <validator_address> <start_height> <end_height>
 ```
 
-#### Query delegator rewards
+#### Query Delegator Rewards
 
 To check current rewards for a delegation (were they to be withdrawn), run:
 
@@ -661,7 +697,7 @@ To check current rewards for a delegation (were they to be withdrawn), run:
 gaiacli query distr rewards <delegator_address> <validator_address>
 ```
 
-#### Query all delegator rewards
+#### Query All Delegator Rewards
 
 To check all current rewards for a delegation (were they to be withdrawn), run:
 
@@ -669,7 +705,7 @@ To check all current rewards for a delegation (were they to be withdrawn), run:
 gaiacli query distr rewards <delegator_address>
 ```
 
-### Multisig transactions
+### Multisig Transactions
 
 Multisig transactions require signatures of multiple private keys. Thus, generating and signing
 a transaction from a multisig account involve cooperation among the parties involved. A multisig
@@ -761,7 +797,7 @@ The transaction can now be sent to the node:
 gaiacli tx broadcast signedTx.json
 ```
 
-## Shells completion scripts
+## Shells Completion Scripts
 
 Completion scripts for popular UNIX shell interpreters such as `Bash` and `Zsh`
 can be generated through the `completion` command, which is available for both
diff --git a/docs/gaia/genesis.md b/docs/cosmos-hub/genesis-state.md
similarity index 100%
rename from docs/gaia/genesis.md
rename to docs/cosmos-hub/genesis-state.md
diff --git a/docs/cosmos-hub/genesis.md b/docs/cosmos-hub/genesis.md
new file mode 100644
index 000000000..427abfe62
--- /dev/null
+++ b/docs/cosmos-hub/genesis.md
@@ -0,0 +1,332 @@
+# Genesis File
+
+This document explains how the genesis file of the Cosmmos Hub mainnet is structured. It also explains how you can build a genesis file for your own `gaia` testnet.
+
+Note that you can generate a default genesis file for your own testnet by running the following command:
+
+```bash
+gaiad init <moniker> --chain-id <chain-id>
+```
+
+The genesis file is stored in `~/.gaiad/config/genesis.toml`.
+
+## What is a Genesis File
+
+A genesis file is a JSON file which defines the initial state of your blockchain. It can be seen as height `0` of your blockchain. The first block, at height `1`, will reference the genesis file as its parent. 
+
+The state defined in the genesis file contains all the necessary information, like initial token allocation, genesis time, default parameters, and more. Let us break down these information.
+
+## Genesis Time and Chain_id 
+
+The `genesis_time` is defined at the top of the genesis file. It is a `UTC` timestamps which specifies when the blockchain is due to start. At this time, genesis validators are supposed to come online and start participating in the consensus process. The blockchain starts when more than 2/3rd of the genesis validators (weighted by voting power) are online. 
+
+```json
+"genesis_time": "2019-03-13T17:00:00.000000000Z",
+```
+
+The `chain_id` is a unique identifier for your chain. It helps differentiate between different chains using the same version of the software.
+
+```json
+"chain_id": "cosmoshub-1",
+```
+
+## Consensus Parameters
+
+Next, the genesis file defines consensus parameters. Consensus parameters regroup all the parameters that are related to the consensus layer, which is `Tendermint` in the case of `gaia`. Let us look at these parameters:
+
+- `block`
+    + `max_bytes`: Maximum number of bytes per block. 
+    + `max_gas`: Gas limit per block. Each transaction included in the block will consume some gas. The total gas used by transactions included in a block cannot exceed this limit.
+- `evidence`
+    + `max_age`: An evidence is a proof that a validator signed two different blocks at the same height (and round). This is an explicitely malicious behaviour that is punished at the state-machine level. The `max_age` defines the maximum number of **blocks** after which an evidence is not valid anymore. 
+- `validator`
+    + `pub_key_types`: The types of pubkey (`ed25519`, `secp256k1`, ...) that are accepted for validators. Currently only `ed25519` is accepted.
+
+```json
+"consensus_params": {
+    "block_size": {
+      "max_bytes": "150000",
+      "max_gas": "1500000"
+    },
+    "evidence": {
+      "max_age": "1000000"
+    },
+    "validator": {
+      "pub_key_types": [
+        "ed25519"
+      ]
+    }
+  },
+```
+
+## Application State
+
+The application state defines the initial state of the state-machine. 
+
+### Genesis Accounts
+
+In this section, initial allocation of tokens is defined. It is possible to add accounts manually by directly editing the genesis file, but it is also possible to use the following command:
+
+```bash
+// Example: gaiad add-genesis-account cosmos1qs8tnw2t8l6amtzvdemnnsq9dzk0ag0z37gh3h 10000000uatom
+
+gaiad add-genesis-account <account-address> <amount><denom>
+```
+
+This command creates an item in the `accounts` list, under the `app_state` section.
+
+```json
+"accounts": [
+      {
+        "address": "cosmos1qs8tnw2t8l6amtzvdemnnsq9dzk0ag0z37gh3h",
+        "coins": [
+          {
+            "denom": "uatom",
+            "amount": "10000000"
+          }
+        ],
+        "sequence_number": "0",
+        "account_number": "0",
+        "original_vesting": [
+          {
+            "denom": "uatom",
+            "amount": "26306000000"
+          }
+        ],
+        "delegated_free": null,
+        "delegated_vesting": null,
+        "start_time": "0",
+        "end_time": "10000"
+      }
+]
+```
+
+Let us break down the parameters:
+
+- `sequence_number`: This number is used to count the number of transactions sent by this account. It is incremented each time a transaction is included in a block, and used to prevent replay attacks. Initial value is `0`.
+- `account_number`: Unique identifier for the account. It is generated the first time a transaction including this account is included in a block.
+- `original_vesting`: Vesting is natively supported by `gaia`. You can define an amount of token owned by the account that needs to be vested for a period of time before they can be transferred. Vested tokens can be delegated. Default value is `null`.
+- `delegated_free`: Amount of delegated tokens that can be transferred after they've been vested. Most of the time, will be `null` in genesis. 
+- `delegated_vesting`: Amount of delegated tokens that are still vesting. Most of the time, will be `null` in genesis.
+- `start_time`: Block at which the vesting period starts. `0` most of the time in genesis.
+- `end_time`: Block at which the vesting period ends. `0` if no vesting for this account.
+
+### Bank 
+
+The `bank` module handles tokens. The only parameter that needs to be defined in this section is wether `transfers` are enabled at genesis or not.
+
+```json
+"bank": {
+      "send_enabled": false
+    }
+```
+
+### Staking
+
+The `staking` module handles the bulk of the Proof-of-Stake logic of the state-machine. This section should look like the following:
+
+```json
+"staking": {
+      "pool": {
+        "not_bonded_tokens": "10000000",
+        "bonded_tokens": "0"
+      },
+      "params": {
+        "unbonding_time": "1814400000000000",
+        "max_validators": 100,
+        "max_entries": 7,
+        "bond_denom": "uatom"
+      },
+      "last_total_power": "0",
+      "last_validator_powers": null,
+      "validators": null,
+      "bonds": null,
+      "unbonding_delegations": null,
+      "redelegations": null,
+      "exported": false
+    }
+```
+
+Let us break down the parameters:
+
+- `pool`
+    + `not_bonded_tokens`: Defines the amount of tokens not bonded (i.e. delegated) in genesis. Generally, it equals the total supply of the staking token (`uatom` in this example).
+    + `bonded_tokens`: Amount of bonded tokens in genesis. Generally `0`.
+- `params`
+    + `unbonding_time`: Time in **nanosecond** it takes for tokens to complete unbonding. 
+    + `max_validators`: Maximum number of active validators. 
+    + `max_entries`: Maximum unbonding delegations and redelegations between a particular pair of delegator / validator.
+    + `bond_denom`: Denomination of the staking token. 
+- `last_total_power`: Total amount of voting power. Generally `0` in genesis (except if genesis was generated using a previous state).
+- `last_validator_powers`: Power of each validator in last known state. Generally `null` in genesis (except if genesis was generated using a previous state).
+- `validators`: List of last knoww validators. Generally `null` in genesis (except if genesis was generated using a previous state).
+- `bonds`: List of last known delegation. Generally `null` in genesis (except if genesis was generated using a previous state).
+- `unbonding_delegations`: List of last known unbonding delegations. Generally `null` in genesis (except if genesis was generated using a previous state).
+- `redelegations`: List of last known redelegations. Generally `null` in genesis (except if genesis was generated using a previous state).
+- `exported`: Wether this genesis was generated using the export of a previous state.
+
+### Mint
+
+The `mint` module governs the logic of inflating the supply of token. The `mint` section in the genesis file looks like the follwing:
+
+```json
+"mint": {
+      "minter": {
+        "inflation": "0.070000000000000000",
+        "annual_provisions": "0.000000000000000000"
+      },
+      "params": {
+        "mint_denom": "uatom",
+        "inflation_rate_change": "0.130000000000000000",
+        "inflation_max": "0.200000000000000000",
+        "inflation_min": "0.070000000000000000",
+        "goal_bonded": "0.670000000000000000",
+        "blocks_per_year": "6311520"
+      }
+    }
+```
+
+Let us break down the parameters:
+
+- `minter`
+    + `inflation`: Initial yearly percentage of increase in the total supply of staking token, compounded weekly. A `0.070000000000000000` value means the target is `7%` yearly inflation, compounded weekly.
+    + `annual_provisions`: Calculated each block. Initialize at `0.000000000000000000`.
+- `params`
+    + `mint_denom`: Denom of the staking token that is inflated.
+    + `inflation_rate_change`: Max yearly change in inflation. 
+    + `inflation_max`: Maximum level of inflation.
+    + `inflation_min`: Minimum level of inflation.
+    + `goal_bonded`: Percentage of the total supply that is targeted to be bonded. If the percentage of bonded staking tokens is below this target, the inflation increases (following `inflation_rate_change`) until it reaches `inflation_max`. If the percentage of bonded staking tokens is above this target, the inflation decreases (following `inflation_rate_change`) until it reaches `inflation_min`.
+    + `blocks_per_year`: Estimation of the amount of blocks per year. Used to compute the block reward coming from inflated staking token (called block provisions). 
+
+### Distribution
+
+The `distr` module handles the logic of distribution block provisions and fees to validators and delegators. The `distr` section in the genesis file looks like the follwing:
+
+```json
+    "distr": {
+      "fee_pool": {
+        "community_pool": null
+      },
+      "community_tax": "0.020000000000000000",
+      "base_proposer_reward": "0.010000000000000000",
+      "bonus_proposer_reward": "0.040000000000000000",
+      "withdraw_addr_enabled": false,
+      "delegator_withdraw_infos": null,
+      "previous_proposer": "",
+      "outstanding_rewards": null,
+      "validator_accumulated_commissions": null,
+      "validator_historical_rewards": null,
+      "validator_current_rewards": null,
+      "delegator_starting_infos": null,
+      "validator_slash_events": null
+    }
+```
+
+Let us break down the parameters:
+
+- `fee_pool`
+    + `community_pool`: The community pool is a pool of tokens that can be used to pay for bounties. It is allocated via governance proposals. Generally `null` in genesis.
+- `community_tax`: The tax percentage on fees and block rewards that goes to the community pool.
+- `base_proposer_reward`: Base bonus on transaction fees collected in a valid block that goes to the proposer of block. If value is `0.010000000000000000`, 1% of the fees go to the proposer. 
+- `bonus_proposer_reward`: Max bonus on transaction fees collected in a valid block that goes to the proposer of block. The bonus depends on the number of `precommits` the proposer includes. If the proposer includes 2/3rd `precommits` weighted by voting power (minimum for the block to be valid), they get a bonus of `base_proposer_reward`. This bonus increases linearly up to `bonus_proposer_reward` if the proposer includes 100% of `precommits`.
+- `withdraw_addr_enabled`: If `true`, delegators can set a different address to withdraw their rewards. Set to `false` if you want to disable transfers at genesis, as it can be used as a way to get around the restriction.
+- `delegator_withdraw_infos`: List of delegators withdraw address. Generally `null` if genesis was not exported from previous state.
+- `previous_proposer`: Proposer of the previous block. Set to `""` if genesis was not exported from previous state.
+- `outstanding_rewards`: Outstanding (un-withdrawn) rewards. Set to `null` if genesis was not exported from previous state.
+- `validator_accumulated_commission`: Outstanding (un-withdrawn) commission of validators. Set to `null` if genesis was not exported from previous state.
+- `validator_historical_rewards`: Set of information related to the historical rewards of validators and used by the `distr` module for various computation. Set to `null` if genesis was not exported from previous state. 
+- `validators_current_rewards`: Set of information related to the current rewards of validators and used by the `distr` module for various computation. Set to `null` if genesis was not exported from previous state.
+- `delegator_starting_infos`: Tracks the previous validator period, the delegation's amount of staking token, and the creation height (to check later on if any slashes have occurred). Set to `null` if genesis was not exported from previous state.
+- `validator_slash_events`: Set of information related to the past slashing of validators. Set to `null` if genesis was not exported from previous state.
+
+### Governance
+
+The `gov` module handles all governance-related transactions. The initial state of the `gov` section looks like the following:
+
+```json
+"gov": {
+      "starting_proposal_id": "1",
+      "deposits": null,
+      "votes": null,
+      "proposals": null,
+      "deposit_params": {
+        "min_deposit": [
+          {
+            "denom": "uatom",
+            "amount": "512000000"
+          }
+        ],
+        "max_deposit_period": "1209600000000000"
+      },
+      "voting_params": {
+        "voting_period": "1209600000000000"
+      },
+      "tally_params": {
+        "quorum": "0.4",
+        "threshold": "0.5",
+        "veto": "0.334",
+        "governance_penalty": "0.0"
+      }
+    }
+```
+
+Let us break down the parameters:
+
+- `starting_proposal_id`: This parameter defines the ID of the first proposal. Each proposal is identified by a unique ID.
+- `deposits`: List of deposits for each proposal ID. Set to `null` if genesis was not exported from previous state.
+- `votes`: List of votes for each proposal ID. Set to `null` if genesis was not exported from previous state.
+- `proposals`: List of proposals for each proposal ID: Set to `null` if genesis was not exported from previous state.
+- `deposit_params`
+    + `min_deposit`: The minimum deposit required for the proposal to enter `Voting Period`. If multiple denoms are provided, the `OR`  operator applies.
+    + `max_deposit_period`: The maximum period (in **nanoseconds**) after which it is not possible to deposit on the proposal anymore.
+- `voting_params`
+    + `voting_period`: Length of the voting period in **nanoseconds**. 
+- `tally_params`
+    + `quorum`: Minimum percentage of bonded staking tokens that needs to vote for the result to be valid.
+    + `threshold`: Minimum percentage of votes that need to be `YES` for the result to be valid.
+    + `veto`: Maximum percentage `NO_WITH_VETO` votes for the result to be valid.
+    + `governance_penalty`: Penalty for validators that do not vote on a given proposal.
+
+### Slashing 
+
+The `slashing` module handles the logic to slash delegators if their validator misbehave. The `slashing` section in genesis looks as follows:
+
+```json
+"slashing": {
+      "params": {
+        "max_evidence_age": "1814400000000000",
+        "signed_blocks_window": "10000",
+        "min_signed_per_window": "0.050000000000000000",
+        "downtime_jail_duration": "600000000000",
+        "slash_fraction_double_sign": "0.050000000000000000",
+        "slash_fraction_downtime": "0.000100000000000000"
+      },
+      "signing_infos": {},
+      "missed_blocks": {}
+    }
+```
+
+Let us break down the parameters:
+
+- `params`
+    + `max_evidence_age`: Maximum age of the evidence in **nanoseconds**.
+    + `signed_blocks_window`: Moving window of blocks to figure out offline validators.
+    + `min_signed_per_window`: Minimum percentage of `precommits`that must be present in the `block window` for the validator to be considered online.
+    + `downtime_jail_duration`: Duration in **nanoseconds** for which a validator is jailed after they get slashed for downtime.
+    + `slash_fraction_double_sign`: Percentage of delegators bonded stake slashed when their validator double signs. 
+    + `slash_fraction_downtime`: Percentage of delegators bonded stake slashed when their validator is down.
+- `signing_infos`: Various infos per validator needed by the `slashing` module. Set to `{}` if genesis was not exported from previous state.
+- `missed_blocks`: Various infos related to missed blocks needed by the `slashing` module. Set to `{}` if genesis was not exported from previous state.
+
+### Genesis Transactions
+
+By default, the genesis file do not contain any `gentxs`. A `gentx` is a transaction that bonds staking token present in the genesis file under `accounts` to a validator, essentially creating a validator at genesis. The chain will start as soon as more than 2/3rds of the validators (weighted by voting power) that are the recipient of a valid `gentx` come online after `genesis_time`.
+
+A `gentx` can be added manually to the genesis file, or via the following command:
+
+```bash
+gaiad collect-gentxs
+```
+
+This command will add all the `gentxs` stored in `~/.gaiad/config/gentx` to the genesis file. In order to create a genesis transaction, click [here](./validators/validator-setup.md#participate-in-genesis-as-a-validator).
diff --git a/docs/gaia/installation.md b/docs/cosmos-hub/installation.md
similarity index 93%
rename from docs/gaia/installation.md
rename to docs/cosmos-hub/installation.md
index f35568ebb..48f0f71a7 100644
--- a/docs/gaia/installation.md
+++ b/docs/cosmos-hub/installation.md
@@ -15,7 +15,7 @@ source ~/.bash_profile
 ```
 
 ::: tip
-**Go 1.11.5+** is required for the Cosmos SDK.
+**Go 1.12.1+** is required for the Cosmos SDK.
 :::
 
 ### Install the binaries
@@ -25,7 +25,7 @@ If necessary, make sure you `git checkout` the correct
 [released version](https://github.com/cosmos/cosmos-sdk/releases).
 
 ::: warning
-For the mainnet, make sure your version if greather than `v0.33.0`
+For the mainnet, make sure your version if greater than `v0.33.0`
 ::: 
 
 ```bash
@@ -66,7 +66,7 @@ Build tags indicate special features that have been enabled in the binary.
 
 ### Install binary distribution via snap (Linux only)
 
-**Do not use snap at this time to install the binaries for production until we have a reproduceable binary system.**
+**Do not use snap at this time to install the binaries for production until we have a reproducible binary system.**
 
 
 ### Next
diff --git a/docs/gaia/join-mainnet.md b/docs/cosmos-hub/join-mainnet.md
similarity index 80%
rename from docs/gaia/join-mainnet.md
rename to docs/cosmos-hub/join-mainnet.md
index d2feece2e..aa947d703 100644
--- a/docs/gaia/join-mainnet.md
+++ b/docs/cosmos-hub/join-mainnet.md
@@ -56,7 +56,7 @@ Fetch the testnet's `genesis.json` file into `gaiad`'s config directory.
 
 ```bash
 mkdir -p $HOME/.gaiad/config
-curl https://raw.githubusercontent.com/cosmos/launch/master/latest/genesis.json > $HOME/.gaiad/config/genesis.json
+curl https://raw.githubusercontent.com/cosmos/launch/master/genesis.json > $HOME/.gaiad/config/genesis.json
 ```
 
 Note we use the `latest` directory in the [launch repo](https://github.com/cosmos/launch) which contains details for the mainnet like the latest version and the genesis file. 
@@ -81,7 +81,7 @@ You can also ask for peers on the [Validators Riot Room](https://riot.im/app/#/r
 
 For more information on seeds and peers, you can [read this](https://github.com/tendermint/tendermint/blob/develop/docs/tendermint-core/using-tendermint.md#peers).
 
-## A note on gas and fees
+## A Note on Gas and Fees
 
 ::: warning
 On Cosmos Hub mainnet, the accepted denom is `uatom`, where `1atom = 1.000.000uatom`
@@ -147,6 +147,36 @@ If you plan to start a new network from the exported state, export with the `--f
 gaiad export --height [height] --for-zero-height > [filename].json
 ```
 
+## Verify Mainnet 
+
+Help to prevent a catastrophe by running invariants on each block on your full
+node. In essence, by running invariants you ensure that the state of mainnet is
+the correct expected state. One vital invariant check is that no atoms are
+being created or destroyed outside of expected protocol, however there are many
+other invariant checks each unique to their respective module. Because invariant checks 
+are computationally expensive, they are not enabled by default. To run a node with 
+these checks start your node with the assert-invariants-blockly flag:
+
+```bash
+gaiad start --assert-invariants-blockly
+```
+
+If an invariant is broken on your node, your node will panic and prompt you to send
+a transaction which will halt mainnet. For example the provided message may look like: 
+
+```bash
+invariant broken:
+    loose token invariance:
+        pool.NotBondedTokens: 100
+        sum of account tokens: 101
+    CRITICAL please submit the following transaction:
+        gaiacli tx crisis invariant-broken staking supply
+
+```
+
+When submitting a invariant-broken transaction, transaction fee tokens are not
+deducted as the blockchain will halt (aka. this is a free transaction). 
+
 ## Upgrade to Validator Node
 
 You now have an active full node. What's the next step? You can upgrade your full node to become a Cosmos Validator. The top 100 validators have the ability to propose new blocks to the Cosmos Hub. Continue onto [the Validator Setup](./validators/validator-setup.md).
diff --git a/docs/gaia/join-testnet.md b/docs/cosmos-hub/join-testnet.md
similarity index 96%
rename from docs/gaia/join-testnet.md
rename to docs/cosmos-hub/join-testnet.md
index 469abdd84..30a7c33d0 100644
--- a/docs/gaia/join-testnet.md
+++ b/docs/cosmos-hub/join-testnet.md
@@ -10,7 +10,7 @@ of the Cosmos-SDK to use and details about the genesis file.
 **You need to [install gaia](./installation.md) before you go further**
 :::
 
-## Starting a new Node
+## Starting a New Node
 
 > NOTE: If you ran a full node on a previous testnet, please skip to [Upgrading From Previous Testnet](#upgrading-from-previous-testnet).
 
@@ -21,7 +21,7 @@ To start a new node, the mainnet instructions apply:
 
 The only difference is the SDK version and genesis file. See the [testnet repo](https://github.com/cosmos/testnets) for information on testnets, including the correct version of the Cosmos-SDK to use and details about the genesis file.
 
-## Upgrading your Node
+## Upgrading Your Node
 
 These instructions are for full nodes that have ran on previous versions of and would like to upgrade to the latest testnet.
 
@@ -59,4 +59,4 @@ make update_tools install
 Note we use `master` here since it contains the latest stable release.
 See the [testnet repo](https://github.com/cosmos/testnets) for details on which version is needed for which testnet, and the [SDK release page](https://github.com/cosmos/cosmos-sdk/releases) for details on each release.
 
-Your full node has been cleanly upgraded!
\ No newline at end of file
+Your full node has been cleanly upgraded!
diff --git a/docs/gaia/keys.md b/docs/cosmos-hub/keys.md
similarity index 100%
rename from docs/gaia/keys.md
rename to docs/cosmos-hub/keys.md
diff --git a/docs/gaia/launch/blog-1-cn.md b/docs/cosmos-hub/launch/blog-1-cn.md
similarity index 100%
rename from docs/gaia/launch/blog-1-cn.md
rename to docs/cosmos-hub/launch/blog-1-cn.md
diff --git a/docs/gaia/launch/blog-1-en.md b/docs/cosmos-hub/launch/blog-1-en.md
similarity index 100%
rename from docs/gaia/launch/blog-1-en.md
rename to docs/cosmos-hub/launch/blog-1-en.md
diff --git a/docs/gaia/launch/blog-1-kr.md b/docs/cosmos-hub/launch/blog-1-kr.md
similarity index 100%
rename from docs/gaia/launch/blog-1-kr.md
rename to docs/cosmos-hub/launch/blog-1-kr.md
diff --git a/docs/gaia/launch/blog-2-cn.md b/docs/cosmos-hub/launch/blog-2-cn.md
similarity index 100%
rename from docs/gaia/launch/blog-2-cn.md
rename to docs/cosmos-hub/launch/blog-2-cn.md
diff --git a/docs/gaia/launch/blog-2-en.md b/docs/cosmos-hub/launch/blog-2-en.md
similarity index 100%
rename from docs/gaia/launch/blog-2-en.md
rename to docs/cosmos-hub/launch/blog-2-en.md
diff --git a/docs/gaia/launch/blog-2-kr.md b/docs/cosmos-hub/launch/blog-2-kr.md
similarity index 100%
rename from docs/gaia/launch/blog-2-kr.md
rename to docs/cosmos-hub/launch/blog-2-kr.md
diff --git a/docs/gaia/ledger.md b/docs/cosmos-hub/ledger.md
similarity index 99%
rename from docs/gaia/ledger.md
rename to docs/cosmos-hub/ledger.md
index 3a36bad87..63038b1a2 100644
--- a/docs/gaia/ledger.md
+++ b/docs/cosmos-hub/ledger.md
@@ -1,6 +1,6 @@
 # Ledger Nano Support
 
-## A note on HD wallet
+## A Note on HD Wallet
 
 HD Wallets, originally specified in Bitcoin's [BIP32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki), are a special kind of wallet that let users derive any number of accounts from a single seed. To understand what that means, let us first define some terminology:
 
@@ -54,7 +54,7 @@ The process of derivating accounts from the seed is deterministic. This means th
 
 The funds stored in an account are controlled by the private key. This private key is generated using a one-way function from the mnemonic. If you lose the private key, you can retrieve it using the mnemonic. However, if you lose the mnemonic, you will lose access to all the derived private keys. Likewise, if someone gains access to your mnemonic, they gain access to all the associated accounts. 
 
-## Ledger Support for account keys
+## Ledger Support for Account Keys
 
 At the core of a Ledger device, there is a mnemonic that is used to generate private keys. When you initialize you Ledger, a mnemonic is generated. 
 
diff --git a/docs/gaia/validators/overview.md b/docs/cosmos-hub/validators/overview.md
similarity index 100%
rename from docs/gaia/validators/overview.md
rename to docs/cosmos-hub/validators/overview.md
diff --git a/docs/gaia/validators/security.md b/docs/cosmos-hub/validators/security.md
similarity index 95%
rename from docs/gaia/validators/security.md
rename to docs/cosmos-hub/validators/security.md
index a5072d719..cb822d45f 100644
--- a/docs/gaia/validators/security.md
+++ b/docs/cosmos-hub/validators/security.md
@@ -2,7 +2,7 @@
 
 Each validator candidate is encouraged to run its operations independently, as diverse setups increase the resilience of the network. Validator candidates should commence their setup phase now in order to be on time for launch.
 
-## Key management - HSM
+## Key Management - HSM
 
 It is mission critical that an attacker cannot steal a validator's key. If this is possible, it puts the entire stake delegated to the compromised validator at risk. Hardware security modules are an important strategy for mitigating this risk.
 
@@ -37,7 +37,9 @@ pex = false
 Sentry Nodes should edit their config.toml:
 ```bash
 # Comma separated list of peer IDs to keep private (will not be gossiped to other peers)
-private_peer_ids = "ipaddress of validator nodes"
+# Example ID: 3e16af0cead27979e1fc3dac57d03df3c7a77acc@3.87.179.235:26656
+
+private_peer_ids = "node_ids_of_private_peers"
 ```
 
 ## Environment Variables
diff --git a/docs/gaia/validators/validator-faq.md b/docs/cosmos-hub/validators/validator-faq.md
similarity index 98%
rename from docs/gaia/validators/validator-faq.md
rename to docs/cosmos-hub/validators/validator-faq.md
index a303989df..38e6e8585 100644
--- a/docs/gaia/validators/validator-faq.md
+++ b/docs/cosmos-hub/validators/validator-faq.md
@@ -16,7 +16,7 @@ The Cosmos Hub is a public Proof-Of-Stake (PoS) blockchain, meaning that the wei
 
 Any user in the system can declare their intention to become a validator by sending a `create-validator` transaction. From there, they become validator candidates.
 
-The weight (i.e. voting power) of a validator determines wether or not they are an active validator. Initially, only the top 100 validators with the most voting power will be active validators. 
+The weight (i.e. voting power) of a validator determines whether or not they are an active validator. Initially, only the top 100 validators with the most voting power will be active validators. 
 
 ### What is a full-node?
 
@@ -94,7 +94,7 @@ After a validator is created with a `create-validator` transaction, they can be
 - `unbonded`: Validator is not in the active set, and therefore not signing blocs. Validator cannot be slashed, and does not earn any reward. It is still possible to delegate Atoms to this validator. Un-delegating from an `unbonded` validator is immediate.
 
 
-### What is 'self-delegation'? How can I increase my 'self-delegatino'?
+### What is 'self-delegation'? How can I increase my 'self-delegation'?
 
 Self-delegation is delegation from a validator to themselves. This amount can be increases by sending a `delegate` transaction from your validator's `application` application key.
 
@@ -113,13 +113,13 @@ Delegators are free to choose validators according to their own subjective crite
 
 Apart from these criteria, there will be a possibility for validators to signal a website address to complete their resume. Validators will need to build reputation one way or another to attract delegators. For example, it would be a good practice for validators to have their setup audited by third parties. Note though, that the Tendermint team will not approve or conduct any audit themselves. For more on due diligence, see [this blog post](https://medium.com/@interchain_io/3d0faf10ce6f)
 
-## Responsibilites
+## Responsibilities
 
 ### Do validators need to be publicly identified?
 
 No, they do not. Each delegator will value validators based on their own criteria. Validators will be able to register a website address when they nominate themselves so that they can advertise their operation as they see fit. Some delegators may prefer a website that clearly displays the team operating the validator and their resume, while others might prefer anonymous validators with positive track records.
 
-### What are the responsiblities of a validator?
+### What are the responsibilities of a validator?
 
 Validators have two main responsibilities:
 
diff --git a/docs/gaia/validators/validator-setup.md b/docs/cosmos-hub/validators/validator-setup.md
similarity index 94%
rename from docs/gaia/validators/validator-setup.md
rename to docs/cosmos-hub/validators/validator-setup.md
index fdf7fad81..4c524b52f 100644
--- a/docs/gaia/validators/validator-setup.md
+++ b/docs/cosmos-hub/validators/validator-setup.md
@@ -55,7 +55,7 @@ When specifying commission parameters, the `commission-max-change-rate` is used
 
 You can confirm that you are in the validator set by using a third party explorer.
 
-## Participate in genesis as a validator
+## Participate in Genesis as a Validator
 
 ::: warning
 The genesis ceremony for the Cosmos Hub mainnet is closed. Please skip to the next section.
@@ -98,7 +98,9 @@ You can then submit your `gentx` on the [launch repository](https://github.com/c
 
 ## Edit Validator Description
 
-You can edit your validator's public description. This info is to identify your validator, and will be relied on by delegators to decide which validators to stake to. Make sure to provide input for every flag below, otherwise the field will default to empty (`--moniker` defaults to the machine name).
+You can edit your validator's public description. This info is to identify your validator, and will be relied on by delegators to decide which validators to stake to. Make sure to provide input for every flag below. If a flag is not included in the command the field will default to empty (`--moniker` defaults to the machine name) if the field has never been set or remain the same if it has been set in the past.
+
+The <key_name> specifies which validator you are editing. If you choose to not include certain flags, remember that the --from flag must be included to identify the validator to update.
 
 The `--identity` can be used as to verify identity with systems like Keybase or UPort. When using with Keybase `--identity` should be populated with a 16-digit string that is generated with a [keybase.io](https://keybase.io) account. It's a cryptographically secure method of verifying your identity across multiple online networks. The Keybase API allows us to retrieve your Keybase avatar. This is how you can add a logo to your validator profile.
 
diff --git a/docs/gaia/what-is-gaia.md b/docs/cosmos-hub/what-is-gaia.md
similarity index 97%
rename from docs/gaia/what-is-gaia.md
rename to docs/cosmos-hub/what-is-gaia.md
index cd5df8cab..c1cb72507 100644
--- a/docs/gaia/what-is-gaia.md
+++ b/docs/cosmos-hub/what-is-gaia.md
@@ -3,7 +3,7 @@
 `gaia` is the name of the Cosmos SDK application for the Cosmos Hub. It comes with 2 main entrypoints:
 
 - `gaiad`: The Gaia Daemon, runs a full-node of the `gaia` application.
-- `gaiacli`: The Gaia command-line interface, which enables interraction with a Gaia full-node.
+- `gaiacli`: The Gaia command-line interface, which enables interaction with a Gaia full-node.
 
 `gaia` is built on the Cosmos SDK using the following modules:
 
diff --git a/docs/intro/README.md b/docs/intro/README.md
index 58e842785..204e2f1f2 100644
--- a/docs/intro/README.md
+++ b/docs/intro/README.md
@@ -8,6 +8,6 @@ It is based on two major principles:
 
 - **Composability:** Anyone can create a module for the Cosmos-SDK, and integrating the already-built modules is as simple as importing them into your blockchain application.
 
-- **Capabilities:** The SDK is inspired by capabilities-based security, and informed by years of wrestling with blockchain state-machines. Most developers will need to access other 3rd party modules when building their own modules. Given that the Cosmos-SDK is an open framework, some of the modules may be malicious, which means there is a need for security principles to reason about inter-module interactions. These principles are based on object-cababilities. In practice, this means that instead of having each module keep an access control list for other modules, each module implements special objects called keepers that can be passed to other modules to grant a pre-defined set of capabilities. For example, if an instance of module A's keepers is passed to module B, the latter will be able to call a restricted set of module A's functions. The capabilities of each keeper are defined by the module's developer, and it's the developer's job to understand and audit the safety of foreign code from 3rd party modules based on the capabilities they are passing into each third party module. For a deeper look at capabilities, jump to [this section](./ocap.md).
+- **Capabilities:** The SDK is inspired by capabilities-based security, and informed by years of wrestling with blockchain state-machines. Most developers will need to access other 3rd party modules when building their own modules. Given that the Cosmos-SDK is an open framework, some of the modules may be malicious, which means there is a need for security principles to reason about inter-module interactions. These principles are based on object-capabilities. In practice, this means that instead of having each module keep an access control list for other modules, each module implements special objects called keepers that can be passed to other modules to grant a pre-defined set of capabilities. For example, if an instance of module A's keepers is passed to module B, the latter will be able to call a restricted set of module A's functions. The capabilities of each keeper are defined by the module's developer, and it's the developer's job to understand and audit the safety of foreign code from 3rd party modules based on the capabilities they are passing into each third party module. For a deeper look at capabilities, jump to [this section](./ocap.md).
 
-### Next, learn more about the [SDK Application Architecture](./sdk-app-architecture.md)
\ No newline at end of file
+### Next, learn more about the [SDK Application Architecture](./sdk-app-architecture.md)
diff --git a/docs/intro/sdk-app-architecture.md b/docs/intro/sdk-app-architecture.md
index 17c75836d..f1c67c416 100644
--- a/docs/intro/sdk-app-architecture.md
+++ b/docs/intro/sdk-app-architecture.md
@@ -32,7 +32,7 @@ The Cosmos SDK gives you maximum flexibility to define the state of your applica
 
 ## Tendermint
 
-As a developer, you just have to define the state machine using the Cosmos-SDK, and [*Tendermint*](https://tendermint.com/docs/introduction/introduction.html) will handle replication over the network for you.
+As a developer, you just have to define the state machine using the Cosmos-SDK, and [*Tendermint*](https://tendermint.com/docs/introduction/what-is-tendermint.html) will handle replication over the network for you.
 
 
 ```
@@ -52,7 +52,7 @@ Blockchain node |  |           Consensus           |  |
 ```
 
 
-Tendermint is an application-agnostic engine that is responsible for handling the *networking* and *consensus* layers of your blockchain. In practice, this means that Tendermint is reponsible for propagating and ordering transaction bytes. Tendermint Core relies on an eponymous Byzantine-Fault-Tolerant (BFT) algorithm to reach consensus on the order of transactions. For more on Tendermint, click [here](https://tendermint.com/docs/introduction/introduction.html).
+Tendermint is an application-agnostic engine that is responsible for handling the *networking* and *consensus* layers of your blockchain. In practice, this means that Tendermint is responsible for propagating and ordering transaction bytes. Tendermint Core relies on an eponymous Byzantine-Fault-Tolerant (BFT) algorithm to reach consensus on the order of transactions. For more on Tendermint, click [here](https://tendermint.com/docs/introduction/what-is-tendermint.html).
 
 Tendermint consensus algorithm works with a set of special nodes called *Validators*. Validators are responsible for adding blocks of transactions to the blockchain. At any given block, there is a validator set V. A validator in V is chosen by the algorithm to be the proposer of the next block. This block is considered valid if more than two thirds of V signed a *[prevote](https://tendermint.com/docs/spec/consensus/consensus.html#prevote-step-height-h-round-r)* and a *[precommit](https://tendermint.com/docs/spec/consensus/consensus.html#precommit-step-height-h-round-r)* on it, and if all the transactions that it contains are valid. The validator set can be changed by rules written in the state-machine. For a deeper look at the algorithm, click [here](https://tendermint.com/docs/introduction/what-is-tendermint.html#consensus-overview).
 
@@ -81,7 +81,7 @@ Tendermint passes transactions from the network to the application through an in
 +---------------------+
 ```
 
-Note that Tendermint only handles transaction bytes. It has no knowledge of what these bytes realy mean. All Tendermint does is to order them deterministically. It is the job of the application to give meaning to these bytes. Tendermint passes the bytes to the application via the ABCI, and expects a return code to inform it if the message was succesful or not. 
+Note that Tendermint only handles transaction bytes. It has no knowledge of what these bytes really mean. All Tendermint does is to order them deterministically. It is the job of the application to give meaning to these bytes. Tendermint passes the bytes to the application via the ABCI, and expects a return code to inform it if the message was successful or not. 
 
 Here are the most important messages of the ABCI:
 
diff --git a/docs/intro/sdk-design.md b/docs/intro/sdk-design.md
index 4202b7b2f..dc52cc932 100644
--- a/docs/intro/sdk-design.md
+++ b/docs/intro/sdk-design.md
@@ -74,9 +74,9 @@ The power of the Cosmos SDK lies in its modularity. SDK applications are built b
                                        v
 ```
 
-Each module can be seen as a little state-machine. Developers need to define the subset of the state handled by the module, as well as custom message types that modify the state (*Note:* Messages are extracted from transactions in `baseapp`'s methods). In general, each module declares its own `KVStore` in the multistore to persist the subset of the state it defines. Most developers will need to access other 3rd party modules when building their own modules. Given that the Cosmos-SDK is an open framework, some of the modules may be malicious, which means there is a need for security principles to reason about inter-module interactions. These principles are based on [object-cababilities](./ocap.md). In practice, this means that instead of having each module keep an access control list for other modules, each module implements special objects called keepers that can be passed to other modules to grant a pre-defined set of capabilities. 
+Each module can be seen as a little state-machine. Developers need to define the subset of the state handled by the module, as well as custom message types that modify the state (*Note:* Messages are extracted from transactions in `baseapp`'s methods). In general, each module declares its own `KVStore` in the multistore to persist the subset of the state it defines. Most developers will need to access other 3rd party modules when building their own modules. Given that the Cosmos-SDK is an open framework, some of the modules may be malicious, which means there is a need for security principles to reason about inter-module interactions. These principles are based on [object-capabilities](./ocap.md). In practice, this means that instead of having each module keep an access control list for other modules, each module implements special objects called keepers that can be passed to other modules to grant a pre-defined set of capabilities. 
 
-SDK modules are defined in the `.x/` folder of the SDK. Some core modules include:
+SDK modules are defined in the `x/` folder of the SDK. Some core modules include:
 
 - `x/auth`: Used to manage accounts and signatures.
 - `x/bank`: Used to enable tokens and token transfers.
diff --git a/docs/spec/auth/01_concepts.md b/docs/spec/auth/01_concepts.md
index 388c5a8ac..6d428d5b0 100644
--- a/docs/spec/auth/01_concepts.md
+++ b/docs/spec/auth/01_concepts.md
@@ -15,7 +15,7 @@ signature verification, as well as costs proportional to the tx size. Operators
 should set minimum gas prices when starting their nodes. They must set the unit
 costs of gas in each token denomination they wish to support:
 
-`gaiad start ... --minimum-gas-prices=0.00001steak;0.05photinos`
+`gaiad start ... --minimum-gas-prices=0.00001stake;0.05photinos`
 
 When adding transactions to mempool or gossipping transactions, validators check
 if the transaction's gas prices, which are determined by the provided fees, meet
diff --git a/docs/spec/circuit-breaker/01_concepts.md b/docs/spec/circuit-breaker/01_concepts.md
new file mode 100644
index 000000000..a0b9162a7
--- /dev/null
+++ b/docs/spec/circuit-breaker/01_concepts.md
@@ -0,0 +1,17 @@
+# Concepts
+
+The intention of the circuit breaker is to have a contingency plan for a
+running network which maintains network liveness. This can be achieved through
+selectively "pausing" functionality of specific modules on a running network.
+The circuit breaker is intended to be enabled through either:
+
+ - governance
+ - for emergencies a special subset of accounts selected by the state machine
+ - a transaction which proves the expected behaviour is broken
+
+## Pause state
+
+The basic pause state of any module simply disables all message routes to
+that module. Beyond that, it may be a appropriate for different modules to
+process begin-block/end-block in an altered "safe" way. 
+
diff --git a/docs/spec/crisis/01_state.md b/docs/spec/crisis/01_state.md
new file mode 100644
index 000000000..1b454ff5a
--- /dev/null
+++ b/docs/spec/crisis/01_state.md
@@ -0,0 +1,14 @@
+# State
+
+## ConstantFee
+
+Due to the anticipated large gas cost requirement to verify an invariant (and
+potential to exceed the maximum allowable block gas limit) a constant fee is
+used instead of the standard gas consumption method. The constant fee is
+intended to be larger than the anticipated gas cost of running the invariant
+with the standard gas consumption method. 
+
+The ConstantFee param is held in the global params store. 
+
+ - Params: `mint/params -> amino(sdk.Coin)`
+
diff --git a/docs/spec/crisis/02_messages.md b/docs/spec/crisis/02_messages.md
new file mode 100644
index 000000000..db3449f1f
--- /dev/null
+++ b/docs/spec/crisis/02_messages.md
@@ -0,0 +1,25 @@
+# Messages
+
+In this section we describe the processing of the crisis messages and the
+corresponding updates to the state. 
+
+## MsgVerifyInvariant
+
+Blockchain invariants can be checked using the `MsgVerifyInvariant` message. 
+
+```golang
+type MsgVerifyInvariant struct {
+	Sender         sdk.AccAddress 
+	InvariantRoute string
+}
+```
+
+This message is expected to fail if: 
+ - the sender does not have enough coins for the constant fee
+ - the invariant route is not registered 
+
+This message checks the invariant provided, and if the invariant is broken it
+panics, halting the blockchain. If the invariant is broken, the constant fee is
+never deducted as the transaction is never committed to a block (equivalent to
+being refunded). However, if the invariant is not broken, the constant fee will
+not be refunded.
diff --git a/docs/spec/crisis/03_tags.md b/docs/spec/crisis/03_tags.md
new file mode 100644
index 000000000..f3509bbda
--- /dev/null
+++ b/docs/spec/crisis/03_tags.md
@@ -0,0 +1,13 @@
+# Tags
+
+The crisis module emits the following events/tags:
+
+## Handlers
+
+### MsgVerifyInvariance
+
+| Key       | Value               |
+|-----------|---------------------|
+| action    | verify_invariant    |
+| sender    | {message-sender}    |
+| invariant | {invariant-route}   |
diff --git a/docs/spec/crisis/README.md b/docs/spec/crisis/README.md
new file mode 100644
index 000000000..b9a9ae7dc
--- /dev/null
+++ b/docs/spec/crisis/README.md
@@ -0,0 +1,16 @@
+# Crisis
+
+## Overview
+
+The crisis module halts the blockchain under the circumstance that a blockchain 
+invariant is broken. Invariants can be registered with the application during the
+application initialization process. 
+
+## Contents
+
+1. **[State](01_state.md)**
+    - [ConstantFee](01_state.md#constantfee)
+2. **[Messages](02_messages.md)**
+    - [MsgVerifyInvariant](02_messages.md#msgverifyinvariant)
+3. **[Tags](03_tags.md)**
+    - [Handlers](03_tags.md#handlers)
diff --git a/docs/spec/governance/01_concepts.md b/docs/spec/governance/01_concepts.md
index 9c287d54f..b032834b3 100644
--- a/docs/spec/governance/01_concepts.md
+++ b/docs/spec/governance/01_concepts.md
@@ -123,7 +123,7 @@ that proposals are accepted if the proportion of `Yes` votes (excluding
 proportion of `NoWithVeto` votes is inferior to 1/3 (excluding `Abstain` 
 votes).
 
-Proposals can be accepted before the end of the voting period if they meet a special condtion. Namely, if the ratio of `Yes` votes to `InitTotalVotingPower`exceeds 2:3, the proposal will be immediately accepted, even if the `Voting period` is not finished. `InitTotalVotingPower` is the total voting power of all bonded Atom holders at the moment when the vote opens. 
+Proposals can be accepted before the end of the voting period if they meet a special condition. Namely, if the ratio of `Yes` votes to `InitTotalVotingPower`exceeds 2:3, the proposal will be immediately accepted, even if the `Voting period` is not finished. `InitTotalVotingPower` is the total voting power of all bonded Atom holders at the moment when the vote opens. 
 This condition exists so that the network can react quickly in case of urgency.
 
 ### Inheritance
@@ -143,7 +143,7 @@ At present, validators are not punished for failing to vote.
 
 ### Governance address
 
-Later, we may add permissionned keys that could only sign txs from certain modules. For the MVP, the `Governance address` will be the main validator address generated at account creation. This address corresponds to a different PrivKey than the Tendermint PrivKey which is responsible for signing consensus messages. Validators thus do not have to sign governance transactions with the sensitive Tendermint PrivKey.
+Later, we may add permissioned keys that could only sign txs from certain modules. For the MVP, the `Governance address` will be the main validator address generated at account creation. This address corresponds to a different PrivKey than the Tendermint PrivKey which is responsible for signing consensus messages. Validators thus do not have to sign governance transactions with the sensitive Tendermint PrivKey.
 
 ## Software Upgrade
 
@@ -172,4 +172,4 @@ Once a block contains more than 2/3rd *precommits* where a common
 nodes, non-validating full nodes and light-nodes) are expected to switch to the
 new version of the software. 
 
-*Note: Not clear how the flip is handled programatically*
+*Note: Not clear how the flip is handled programmatically*
diff --git a/docs/spec/governance/02_state.md b/docs/spec/governance/02_state.md
index 4a2fd08d1..d72afc061 100644
--- a/docs/spec/governance/02_state.md
+++ b/docs/spec/governance/02_state.md
@@ -55,7 +55,7 @@ type ProposalStatus byte
 
 const (
     ProposalStatusOpen      = 0x1   // Proposal is submitted. Participants can deposit on it but not vote
-    ProposalStatusActive    = 0x2   // MinDeposit is reachhed, participants can vote
+    ProposalStatusActive    = 0x2   // MinDeposit is reached, participants can vote
     ProposalStatusAccepted  = 0x3   // Proposal has been accepted
     ProposalStatusRejected  = 0x4   // Proposal has been rejected
     ProposalStatusClosed   = 0x5   // Proposal never reached MinDeposit
@@ -84,13 +84,11 @@ This type is used in a temp map when tallying
 
 ## Proposals
 
-`Proposals` are an item to be voted on.
+`Proposals` are an item to be voted on. It contains the `ProposalContent` which denotes what this proposal is about, and the other fields, which are the mutable state of the governance process.
 
 ```go
 type Proposal struct {
-  Title                 string              //  Title of the proposal
-  Description           string              //  Description of the proposal
-  Type                  ProposalType        //  Type of proposal. Initial set {PlainTextProposal, SoftwareUpgradeProposal}
+  ProposalContent                           // Proposal content interface
   TotalDeposit          sdk.Coins           //  Current deposit on this proposal. Initial value is set at InitialDeposit
   Deposits              []Deposit           //  List of deposits on the proposal
   SubmitTime            time.Time           //  Time of the block where TxGovSubmitProposal was included
@@ -108,6 +106,17 @@ type Proposal struct {
 }
 ```
 
+`ProposalContent`s are an interface which contains the information about the `Proposal` where it is provided from an external source, including the proposer. Governance process itself does not evaluate about the internal content.
+
+```go
+type ProposalContent interface {
+    GetTitle() string
+    GetDescription() string
+    ProposalType() ProposalKind
+}
+
+```
+
 We also mention a method to update the tally for a given proposal:
 
 ```go
diff --git a/docs/spec/ibc/README.md b/docs/spec/ibc/README.md
index b42bb3592..69abd3ff0 100644
--- a/docs/spec/ibc/README.md
+++ b/docs/spec/ibc/README.md
@@ -1,5 +1,7 @@
 # Cosmos Inter-Blockchain Communication (IBC) Protocol
 
+> This specification is outdated and no longer in use. For the latest IBC specifications, please see the [Interchain Standards repository](https://github.com/cosmos/ics).
+
 ## Abstract
 
 This paper specifies the Cosmos Inter-Blockchain Communication (IBC) protocol. The IBC protocol defines a set of semantics for authenticated, strictly-ordered message passing between two blockchains with independent consensus algorithms.  
diff --git a/docs/spec/mint/01_concepts.md b/docs/spec/mint/01_concepts.md
new file mode 100644
index 000000000..14b2c6abd
--- /dev/null
+++ b/docs/spec/mint/01_concepts.md
@@ -0,0 +1,22 @@
+# Concepts
+
+## The Minting Mechanism
+
+The minting mechanism was designed to:
+ - allow for a flexible inflation rate determined by market demand targeting a particular bonded-stake ratio
+ - effect a balance between market liquidity and staked supply
+
+In order to best determine the appropriate market rate for inflation rewards, a
+moving change rate is used.  The moving change rate mechanism ensures that if
+the % bonded is either over or under the goal %-bonded, the inflation rate will
+adjust to further incentivize or disincentivize being bonded, respectively. Setting the goal
+%-bonded at less than 100% encourages the network to maintain some non-staked tokens
+which should help provide some liquidity.
+
+It can be broken down in the following way: 
+ - If the inflation rate is below the goal %-bonded the inflation rate will
+   increase until a maximum value is reached
+ - If the goal % bonded (67% in Cosmos-Hub) is maintained, then the inflation
+   rate will stay constant 
+ - If the inflation rate is above the goal %-bonded the inflation rate will
+   decrease until a minimum value is reached
diff --git a/docs/spec/mint/01_state.md b/docs/spec/mint/02_state.md
similarity index 100%
rename from docs/spec/mint/01_state.md
rename to docs/spec/mint/02_state.md
diff --git a/docs/spec/mint/02_begin_block.md b/docs/spec/mint/03_begin_block.md
similarity index 100%
rename from docs/spec/mint/02_begin_block.md
rename to docs/spec/mint/03_begin_block.md
diff --git a/docs/spec/slashing/04_begin_block.md b/docs/spec/slashing/04_begin_block.md
index 4bc677ded..e54d9a210 100644
--- a/docs/spec/slashing/04_begin_block.md
+++ b/docs/spec/slashing/04_begin_block.md
@@ -84,7 +84,7 @@ single slashing period is capped as described in [overview.md](overview.md) unde
 
 ## Uptime tracking
 
-At the beginning of each block, we update the signing info for each validator and check if they've dipped below the liveness threshhold over the tracked window.  If so, they will be slashed by `LivenessSlashAmount` and will be Jailed for `LivenessJailPeriod`.  Liveness slashes do NOT lead to a tombstombing.
+At the beginning of each block, we update the signing info for each validator and check if they've dipped below the liveness threshold over the tracked window.  If so, they will be slashed by `LivenessSlashAmount` and will be Jailed for `LivenessJailPeriod`.  Liveness slashes do NOT lead to a tombstombing.
 
 ```
 height := block.Height
diff --git a/docs/spec/staking/01_state.md b/docs/spec/staking/01_state.md
index b730de8a5..72b9e0908 100644
--- a/docs/spec/staking/01_state.md
+++ b/docs/spec/staking/01_state.md
@@ -212,7 +212,7 @@ type RedelegationEntry struct {
 All queues objects are sorted by timestamp. The time used within any queue is
 first rounded to the nearest nanosecond then sorted. The sortable time format
 used is a slight modification of the RFC3339Nano and uses the the format string
-`"2006-01-02T15:04:05.000000000"`. Noteably This format: 
+`"2006-01-02T15:04:05.000000000"`. Notably this format: 
 
  - right pads all zeros
  - drops the time zone info (uses UTC) 
diff --git a/docs/translations/cn/gaia/README.md b/docs/translations/cn/gaia/README.md
new file mode 100644
index 000000000..592679d42
--- /dev/null
+++ b/docs/translations/cn/gaia/README.md
@@ -0,0 +1,23 @@
+# gaia文档
+
+欢迎阅读`Gaia`文档。 `Gaia`是Cosmos Hub目前的应用程序名。
+
+## 加入Cosmos Hub主网
+
+- [安装`gaia`程序](./installation.md)
+- [启动一个全节点并加入主网](./join-mainnet.md)
+- [升级成一个验证人节点](./validators/validator-setup.md)
+
+## 加入Cosmos Hub公共测试网
+
+- [加入测试网](./join-testnet.md)
+
+## 部署你自己的`gaia`测试网络
+
+- [部署你自己的`gaia`测试网](./deploy-testnet.md)
+
+## 额外资源
+
+- [验证人介绍](./validators/overview.md)
+- [验证人问答](./validators/validator-faq.md)
+- [验证人安全性考量](./validators/security.md)
diff --git a/docs/translations/cn/gaia/delegator-guide-cli.md b/docs/translations/cn/gaia/delegator-guide-cli.md
new file mode 100644
index 000000000..ed0416313
--- /dev/null
+++ b/docs/translations/cn/gaia/delegator-guide-cli.md
@@ -0,0 +1,519 @@
+# 委托人指南 (CLI)
+
+
+本文介绍了如何使用Cosmos Hub的命令行交互（CLI）程序实现通证委托的相关知识和操作步骤。 
+
+同时，本文也介绍了如何管理账户，如何从筹款人那里恢复账户，以及如何使用一个硬件钱包的相关知识。 
+
+::: 风险提示
+
+**重要提示**：请务必按照下面的操作步骤谨慎操作，过程中发生任何错误都有可能导致您永远失去所拥有的通证。因此，请在开始操作之前先仔细阅读全文，如果有任何问题可以联系我们获得支持。 
+
+
+另请注意，您即将要与Cosmos Hub进行交互，Cosmos Hub仍然是一个试验型的区块链技术软件。虽然Cosmos Hub区块链是应用现有最新技术开发并经过审核的，但我们仍然可能会在运行时遇到问题，需要不断更新和修复漏洞。此外，使用区块链技术仍然要求有很高的技术能力，并且有可能遇到我们无法预知和控制的风险。使用Cosmos Hub前，您需要充分了解与加密软件相关的潜在风险（请参考[Cosmos跨链贡献条款](https://github.com/cosmos/cosmos/blob/master/fundraiser/Interchain%20Cosmos%20Contribution%20Terms%20-%20FINAL.pdf)中关于风险的部分条款），并且我们跨链基金会和(或)Tendermint团队对于因为使用本产品而可能产生的损失不承担任何责任。使用Cosmos Hub需要遵守Apache 2.0开源软件授权条款，用户需要自己承担所有责任，所使用的软件按“现状”提供且不提供任何形式的保障或条件。 
+:::
+
+
+请务必谨慎行事！
+
+## 目录
+    
+- [安装 `gaiacli`](#安装-gaiacli)
+- [Cosmos账户](#Cosmos账户)
+    + [通过募资人恢复一个账户](#通过募资人恢复一个账户)
+    + [创建一个账户](#创建一个账户)
+- [访问Cosmos Hub网络](#访问Cosmos-Hub网络)
+    + [运行您自己的全节点](#运行您自己的全节点)
+    + [连接到一个远程全节点](#连接到一个远程全节点)
+- [设置`gaiacli`](#设置-gaiacli)
+- [状态查询](#状态查询)
+- [发起交易](#发起交易)
+    + [关于gas费和手续费](#关于gas费和手续费)
+    + [抵押Atom通证 & 提取奖励](#抵押atom通证--提取奖励)
+    + [参与链上治理](#参与链上治理)
+    + [从一台离线电脑上签署交易](#从一台离线电脑上签署交易)
+
+## 安装 `gaiacli` 
+
+`gaiacli`: 与`gaiad`全节点交互的命令行用户界面。 
+
+::: 安全提示
+
+**请检查并且确认你下载的`gaiacli`是可获得的最新稳定版本**
+:::
+
+
+[**下载已编译代码**]暂不提供
+
+
+[**通过源代码安装**](https://cosmos.network/docs/gaia/installation.html)
+
+::: tip 提示 
+
+`gaiacli` 需要通过操作系统的终端窗口使用，打开步骤如下所示： 
+- **Windows**: `开始` > `所有程序` > `附件` > `终端`
+- **MacOS**: `访达` > `应用程序` > `实用工具` > `终端`
+- **Linux**: `Ctrl` + `Alt` + `T`
+:::
+
+## Cosmos账户
+
+每个Cosmos账户的核心基础是一个包含12或24个词的助记词组，通过这个助记词可以生成无数个Cosmos账户，例如，一组私钥/公钥对。这被称为一个硬件钱包（跟多硬件钱包相关说明请参见[BIP32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)）  
+
+```
+        账户 0                            账户 1                              账户 2
+
++------------------+              +------------------+               +------------------+
+|                  |              |                  |               |                  |
+|       地址 0      |              |      地址 1      |               |       地址 2      |
+|        ^         |              |        ^         |               |        ^         |
+|        |         |              |        |         |               |        |         |
+|        |         |              |        |         |               |        |         |
+|        |         |              |        |         |               |        |         |
+|        +         |              |        +         |               |        +         |
+|       公钥 0      |              |      公钥 1      |               |       公钥 2      |
+|        ^         |              |        ^         |               |        ^         |
+|        |         |              |        |         |               |        |         |
+|        |         |              |        |         |               |        |         |
+|        |         |              |        |         |               |        |         |
+|        +         |              |        +         |               |        +         |
+|       私钥 0      |              |      私钥 1      |               |       私钥 2      |
+|        ^         |              |        ^         |               |        ^         |
++------------------+              +------------------+               +------------------+
+         |                                 |                                  |
+         |                                 |                                  |
+         |                                 |                                  |
+         +--------------------------------------------------------------------+
+                                           |
+                                           |
+                                 +---------+---------+
+                                 |                   |
+                                 |  助记词 (Seed)     |
+                                 |                   |
+                                 +-------------------+
+```
+
+
+私钥是控制一个账户中所存资产的钥匙。私钥是通过助记词单向产生的。如果您不小心丢失了私钥，你可以通过助记词恢复。 然而，如果你丢失了助记词，那么你就有可能失去对由这个助记词产生的所有私钥的控制。同样，如果有人获得了你的助记词，他们就可以操作所有相关账户。  
+
+::: 警告
+
+**谨慎保管并不要告诉他人你的助记词。 为了防止资产被盗或者丢失，您最好多备份几份助记词， 并且把它们存放在只有您知道的安全地方，这样做将有助于保障您的私钥以及相关账户的安全。**
+:::
+
+
+Cosmos地址是一个以可读词开头的字符串(比如`cosmos10snjt8dmpr5my0h76xj48ty80uzwhraqalu4eg`) 如果有人想给你转账通证，他们就往这个地址转账。根据给定地址来推算私钥是不可行的。
+
+### 通过募资人恢复一个账户
+
+::: 提示
+
+*注：这部分内容仅适用于众筹活动参与者*
+:::
+
+
+如果您是众筹的参与者，你应该有一个助记词。新产生的助记词用24个词，但是12个词的助记词组也兼容所有Cosmos工具。 
+
+#### 通过硬件钱包设备进行操作
+
+
+一个数字钱包设备的核心是通过一个助记词在多个区块链上创建账户（包括Cosmos hub）。通常，您会在初始化您的数字钱包设备时创建一个新的助记词,也可以通过已有的助记词进行导入。让我们一起来看如何将您在参与众筹时获得的助记词设定为一个数字钱包设备的seed。
+
+::: 警告
+
+*注意：**最好使用一个新的钱包设备**来恢复您的Cosmos账户。确实，每个数字钱包设备只能有一个助记词。 当然，您可以通过 `设置`>`设备`>`重置所有` 将一个已经有助记词的（用过的）数字钱包重新初始化。**但请注意，这样会清空您设备中现有的助记词，如果您没有做好备份的话，有可能会丢失您的资产***
+:::
+
+
+对于一个没有初始化的数字钱包设备，您需要做如下操作。 
+
+
+1. 将您的数字钱包设备通过USB与电脑链接
+2. 同时按下两个按钮
+3. **不要**选择“配置一个新设备”选项，而是选择“恢复配置”
+4. 选择一个PIN
+5. 选择12个词选项
+6. 逐个按顺序输入您在众筹时获得的12个助记词 
+
+
+现在，您的钱包已经正确地设置好您在众筹时获得的助记词，切勿丢失！任何时候您的钱包设备出现问题，您都可以通过助记词在一个新的钱包设备上恢复所有账户。 
+
+
+接下来，请点击[这里](#使用硬件钱包设备进行操作)来学习如何生成一个账户。
+
+#### 在电脑上操作
+
+::: 警告
+
+**注意： 在一台没有联网的计算机上执行以下操作会更加安全**
+::: 
+
+如果您希望通过众筹时获得的助记词恢复账户并保存相关私钥，请按以下步骤操作： 
+
+```bash
+gaiacli keys add <yourKeyName> --recover
+```
+
+
+首先，您需要输入一个密码来对您硬盘上账户`0`的私钥进行加密。每次您发出一笔交易时都将需要输入这个密码。如果您丢失了密码，您可以通过助记词来恢复您的私钥。 
+
+
+-`<yourKeyName>` 是账户名称，用来指代用助记词生成私钥/公钥对的Cosmos账户。在您发起交易时，这个账户名称被用来识别您的账户。 
+  
+
+- 您可以通过增加 `--account` 标志来指定您账户生成的路径 (`0`, `1`, `2`, ...)， `0` 是缺省值。
+
+
+### 创建一个账户
+
+前，您需要先安装`gaiacli`，同时，您需要知道你希望在哪里保存和使用您的私钥。 最好的办法是把他们保存在一台没有上网的电脑或者一个硬件钱包设备里面。 将私钥保存在一台联网的电脑里面比较危险，任何人通过网络攻击都有可能获取您的私钥，进而盗取您的资产。 
+
+#### 使用硬件钱包设备进行操作
+
+::: 警告
+
+**建议仅使用您新买的钱包设备或者您足够信任的设备**
+:::
+
+当您初始化钱包设备时，设备会产生一个24个词的助记词组。这个助记词组和Cosmos是兼容的，我们可以通过这个助记词组创建Cosmos账户。所以，您需要做的是确认您的钱包设备兼容`gaiacli`，通过下面的步骤可以帮助您确认您的设备是否兼容：
+
+   
+1. 下载[Ledger Live应用](https://www.ledger.com/pages/ledger-live). 
+2. 通过USB将钱包与计算机连接，并且将钱包固件升级到最新版本。 
+3. 到Ledger Live钱包的应用商店下载”Cosmos“应用（这可能需要花些时间）。**下载”Cosmos“应用程序需要在Ledger Live钱包`Settings`选项中激活`Dev Mode`**
+4. 在你的钱包设备上操作Cosmos APP。
+
+
+然后，通过以下命令创建账户：
+
+```bash
+gaiacli keys add <yourAccountName> --ledger 
+```
+
+::: 注意： 该命令仅在硬件钱包已导入并在解锁状态时才有效:::
+
+
+- `<yourKeyName>` 是账户名称，用来指代用助记词生成私钥/公钥对的Cosmos账户。在您发起交易时，这个账户名称被用来识别您的账户。 
+  
+
+- 您可以通过增加 `--account` 标志来指定您账户生成的路径 (`0`, `1`, `2`, ...)， `0` 是缺省值。
+
+#### 使用电脑设备进行操作
+
+::: 警告
+
+**注意：在一台没有联网的电脑上操作会更加安全**
+:::
+
+然后，通过以下命令创建账户：
+
+```bash
+gaiacli keys add <yourKeyName>
+```
+
+这个命令会产生一个24个词的助记词组，并且同时保存账户 `0` 的私钥和公钥。 另外，您还需要输入一个密码来对您硬盘上账户`0`的私钥进行加密。 每次您发出一笔交易时都将需要输入这个密码。如果您丢失了密码，您可以通过助记词来恢复您的私钥。 
+
+::: 危险提示
+
+**千万不要丢失或者告诉其他人你的12个词的助记词组。 为了防止资产被盗或者丢失，您最好多备份几份助记词， 并且把它们存放在只有您知道的安全地方，如果有人取得您的助记词，那么他也就取得了您的私钥并且可以控制相关账户。**
+::: 
+
+::: 警告
+在确认已经安全保存好您的助记词以后（至少3遍！），你可以用如下命令清除终端窗口中的命令历史记录，以防有人通过历史记录获得您的助记词。 
+
+```bash
+history -c
+rm ~/.bash_history
+```
+:::
+
+你可以用以下命令使用助记词生成多个账户： 
+
+```bash
+gaiacli keys add <yourKeyName> --recover --account 1
+```
+
+- - `<yourKeyName>` 是账户名称，用来指代用助记词生成私钥/公钥对的Cosmos账户。在您发起交易时，这个账户名称用来识别您的账户。 
+  
+- 您可以通过增加 `--account` 标志来指定您账户生成的路径 (`0`, `1`, `2`, ...)， `0` 是缺省值。
+
+
+这条命令需要您输入一个密码。改变账号就代表生成了一个新的账户。  
+
+## 访问Cosmos Hub网络
+
+
+为了查询网络状态和发起交易，你需要通过自建一个全节点，或者连接到其他人的全节点访问Cosmos Hub网络
+
+::: 警告
+
+**注意： 请不要与任何人分享您的助记词，您是唯一需要知道这些助记词的人。如果任何人通过邮件或者其他社交媒体向您要求您提供您的助记词，那就需要警惕了。 请记住，Cosmos/Tendermint团队，或跨链基金会永远不会通过邮件要求您提供您的账户密码或助记词。**
+::: 
+
+### 运行您自己的全节点
+
+
+这是最安全的途径，但需要相当多的资源。您需要有较大的带宽和至少1TB的磁盘容量来运行一个全节点。  
+
+
+ `gaia`的安装教程在[这里](https://cosmos.network/docs/gaia/installation.html)， 如何运行一个全节点指导在[这里](https://cosmos.network/docs/gaia/join-testnet.html)
+
+### 连接到一个远程全节点
+
+
+如果您不想或没有能力运行一个全节点，您也可以连接到其他人的全节点。您需要谨慎的选择一个可信的运营商，因为恶意的运营商往往会向您反馈错误的查询结果，或者对您的交易进行监控。 然而，他们永远也无法盗取您的资产，因为您的私钥仅保持在您的本地计算机或者钱包设备中。 验证人，钱包供应商或者交易所是可以提供全节点的运营商。 
+
+
+连接到其他人提供的全节点，你需要一个全节点地址，如`https://77.87.106.33:26657`。这个地址是您的供应商提供的一个可信的接入地址。你会在下一节中用到这个地址。 
+
+## 设置 `gaiacli`
+
+::: 提示
+
+**在开始设置 `gaiacli`前，请确认你已经可以[访问Cosmos Hub网络](#访问cosmos-hub网络)**
+:::
+
+::: 警告
+
+**请确认您使用的`gaiacli`是最新的稳定版本**
+:::
+
+无论您是否在自己运行一个节点，`gaiacli` 都可以帮您实现与Cosmos Hub网络的交互。让我们来完成对它的配置。 
+
+
+您需要用下面的命令行完成对`gaiacli`的配置：
+
+```bash
+gaiacli config <flag> <value>
+```
+
+
+此命名允许您为每个参数设置缺省值。 
+
+
+首先，设置你想要访问的全节点的地址：
+
+```bash
+gaiacli config node <host>:<port
+
+// 样例: gaiacli config node https://77.87.106.33:26657
+```
+
+
+如果你是自己运行全节点，可以使用 `tcp://localhost:26657` 作为地址。 
+
+
+然后，让我们设置 `--trust-node` 指标的缺省值。 
+
+```bash
+gaiacli config trust-node false
+
+// Set to true if you run a light-client node, false otherwise
+```
+
+最后，让我们设置需要访问区块链的 `chain-id` 
+
+```bash
+gaiacli config chain-id gos-6
+```
+
+## 状态查询
+
+::: 提示
+** 准备抵押ATOM通证和取回奖励前，需要先完成 [`gaiacli` 配置](#设置-gaiacli)**
+:::
+
+
+`gaiacli` 可以帮助您获得所有区块链的相关信息， 比如账户余额，抵押通证数量，奖励，治理提案以及其他信息。下面是一组用于委托操作的命令
+
+```bash
+
+// 查询账户余额或者其他账户相关信息
+gaiacli query account
+
+
+// 查询验证人列表
+gaiacli query staking validators
+
+
+// 查询指定地址的验证人的信息(e.g. cosmosvaloper1n5pepvmgsfd3p2tqqgvt505jvymmstf6s9gw27)
+gaiacli query staking validator <validatorAddress>
+
+
+//查询指定地址的验证人相关的所有委托信息 (e.g. cosmos10snjt8dmpr5my0h76xj48ty80uzwhraqalu4eg)
+gaiacli query staking delegations <delegatorAddress>
+
+// 查询从一个指定地址的委托人(e.g. cosmos10snjt8dmpr5my0h76xj48ty80uzwhraqalu4eg)和一个指定地址的验证人(e.g. cosmosvaloper1n5pepvmgsfd3p2tqqgvt505jvymmstf6s9gw27) 之间的委托交易
+gaiacli query staking delegation <delegatorAddress> <validatorAddress>
+
+// 查询一个指定地址的委托人(e.g. cosmos10snjt8dmpr5my0h76xj48ty80uzwhraqalu4eg)所能获得的奖励情况
+gaiacli query distr rewards <delegatorAddress> 
+
+// 查询所有现在正等待抵押的提案
+gaiacli query gov proposals --status deposit_period
+
+//查询所有现在正等待投票的填
+gaiacli query gov proposals --status voting_period
+
+// 查询一个指定propsalID的提案信息
+gaiacli query gov proposal <proposalID>
+```
+
+需要了解跟多的命令，只需要用：
+
+```bash
+gaiacli query
+```
+
+对于每条命令，您都可以使用`-h` 或 `--help` 参数来获得更多的信息。 
+
+## 发起交易
+
+### 关于gas费和手续费
+
+
+Cosmos Hub网络上的交易在被执行时需要支付手续费。这个手续费是用于支付执行交易所需的gas。计算公式如下： 
+```
+fees = gas * gasPrices
+```
+
+`gas` 的多少取决于交易类型，不同的交易类型会收取不同的 `gas` 。每个交易的 `gas` 费是在实际执行过程中计算的，但我们可以通过设置 `gas` 参数中的 `auto` 值实现在交易前对 `gas` 费的估算，但这只是一个粗略的估计，你可以通过 `--gas-adjustment` (缺省值 `1.0`) 对预估的`gas` 值进行调节，以确保为交易支付足够的`gas` 。 
+
+`gasPrice` 用于设置单位 `gas` 的价格。每个验证人会设置一个最低gas价`min-gas-price`, 并只会将`gasPrice`大于`min-gas-price`的交易打包。 
+
+交易的`fees` 是`gas` 和 `gasPrice`的乘积。作为一个用户，你需要输入3个参数中至少2个， `gasPrice`/`fees`的值越大，您的交易就越有机会被打包执行。 
+
+### 抵押Atom通证 & 提取奖励
+
+::: 提示
+**在您抵押通证或取回奖励之前，您需要完成[`gaiacli` 设置](#设置-gaiacli) 和 [创建账户](#创建一个账户)**
+:::
+
+::: 警告
+**在抵押通证前，请仔细阅读[委托者常见问题](https://cosmos.network/resources/delegators) 并且理解其中的风险和责任**
+:::
+
+::: 警告
+**注意：执行以下命令需要在一台联网的计算机。用一个硬件钱包设备执行这些命令会更安全。关于离线交易过程请看[这里](#从一台离线电脑上签署交易).**
+::: 
+
+```bash
+// 向指定验证人绑定一定数量的Atom通证
+// 参数设定样例: <validatorAddress>=cosmosvaloper18thamkhnj9wz8pa4nhnp9rldprgant57pk2m8s, <amountToBound>=10000000000uatom, <gasPrice>=1000uatom
+
+gaiacli tx staking delegate <validatorAddress> <amountToBond> --from <delegatorKeyName> --gas auto --gas-prices <gasPrice>
+
+
+// 提取所有的奖励
+// 参数设定样例: <gasPrice>=1000uatom
+
+gaiacli tx distr withdraw-all-rewards --from <delegatorKeyName> --gas auto --gas-prices <gasPrice>
+
+
+// 向指定验证人申请解绑一定数量的Atom通证
+// 解绑的通证需要3周后才能完全解绑并可以交易，
+// 参数设定样例: <validatorAddress>=cosmosvaloper18thamkhnj9wz8pa4nhnp9rldprgant57pk2m8s, <amountToUnbound>=10000000000uatom, <gasPrice>=1000uatom
+
+gaiacli tx staking unbond <validatorAddress> <amountToUnbond> --from <delegatorKeyName> --gas auto --gas-prices <gasPrice>
+```
+
+::: 提示
+::: 
+如果您是使用一个联网的钱包设备，在交易被广播到网络前您需要在设备上确认交易。 
+
+确认您的交易已经发出，可以用以下查询：
+
+```bash
+// 您的账户余额在您抵押Atom通证或者取回奖励后会发生变化
+gaiacli query account
+
+// 您在抵押后应该能查到委托交易
+gaiacli query staking delegations <delegatorAddress>
+
+// 如果交易已经被打包，将会返回交易记录（tx）
+// 在以下查询命令中可以使用显示的交易哈希值作为参数
+gaiacli query tx <txHash>
+
+```
+
+如果您是连接到一个可信全节点的话，您可以通过一个区块链浏览器做检查。 
+
+## 参与链上治理
+
+#### 链上治理入门
+
+Cosmos Hub有一个内建的治理系统，该系统允许抵押通证的持有人参与提案投票。系统现在支持3种提案类型：
+
+- `Text Proposals`: 这是最基本的一种提案类型，通常用于获得大家对某个网络治理意见的观点。 
+- `Parameter Proposals`: 这种提案通常用于改变网络参数的设定。 
+- `Software Upgrade Proposal`: 这个提案用于升级Hub的软件。 
+
+任何Atom通证的持有人都能够提交一个提案。为了让一个提案获准公开投票，提议人必须要抵押一定量的通证 `deposit`，且抵押值必须大于 `minDeposit` 参数设定值. 提案的抵押不需要提案人一次全部交付。如果早期提案人交付的 `deposit` 不足，那么提案进入 `deposit_period` 状态。 此后，任何通证持有人可以通过 `depositTx` 交易增加对提案的抵押。 
+
+当`deposit` 达到 `minDeposit`，提案进入2周的 `voting_period` 。 任何**抵押了通证**的持有人都可以参与对这个提案的投票。投票的选项有`Yes`, `No`, `NoWithVeto` 和 `Abstain`。投票的权重取决于投票人所抵押的通证数量。如果通证持有人不投票，那么委托人将继承其委托的验证人的投票选项。当然，委托人也可以自己投出与所委托验证人不同的票。  
+
+
+当投票期结束后，获得50%（不包括投`Abstain `票）以上 `Yes` 投票权重且少于33.33% 的`NoWithVeto`（不包括投`Abstain `票）提案将被接受， 
+
+#### 实践练习
+
+::: 提示
+**在您能够抵押通证或者提取奖励以前，您需要了解[通证抵押](#抵押atom通证--提取奖励)**
+:::
+
+::: 警告
+
+**注意：执行以下命令需要一台联网的计算机。用一个硬件钱包设备执行这些命令会更安全。关于离线交易过程请看[这里](#从一台离线电脑上签署交易).**
+::: 
+
+```bash
+// 提交一个提案
+// <type>=text/parameter_change/software_upgrade
+// ex value for flag: <gasPrice>=100uatom
+
+gaiacli tx gov submit-proposal --title "Test Proposal" --description "My awesome proposal" --type <type> --deposit=10000000uatom --gas auto --gas-prices <gasPrice> --from <delegatorKeyName>
+
+// 增加对提案的抵押
+// Retrieve proposalID from $gaiacli query gov proposals --status deposit_period
+// 通过 $gaiacli query gov proposals --status deposit_period 命令获得 `proposalID` 
+// 参数设定样例: <deposit>=1000000uatom
+
+gaiacli tx gov deposit <proposalID> <deposit> --gas auto --gas-prices <gasPrice> --from <delegatorKeyName>
+
+// 对一个提案投票
+// Retrieve proposalID from $gaiacli query gov proposals --status voting_period 
+通过 $gaiacli query gov proposals --status deposit_period 命令获得 `proposalID` 
+// <option>=yes/no/no_with_veto/abstain
+
+gaiacli tx gov vote <proposalID> <option> --gas auto --gas-prices <gasPrice> --from <delegatorKeyName>
+```
+
+### 从一台离线电脑上签署交易
+
+
+如果你没有数字钱包设备，而且希望和一台存有私钥的没有联网的电脑进行交互，你可以使用如下过程。首先，在**联网的电脑上**生成一个没有签名的交易，然后通过下列命令操作（下面以抵押交易为例）：
+
+```bash
+// 抵押Atom通证
+// 参数设定样例: <amountToBound>=10000000000uatom, <bech32AddressOfValidator>=cosmosvaloper18thamkhnj9wz8pa4nhnp9rldprgant57pk2m8s, <gasPrice>=1000uatom
+
+gaiacli tx staking delegate <validatorAddress> <amountToBond> --from <delegatorKeyName> --gas auto --gas-prices <gasPrice> --generate-only > unsignedTX.json
+```
+
+然后，复制 `unsignedTx.json` 并且帮它转移到没有联网的电脑上（比如通过U盘）。如果没有在没联网的电脑上建立账户，可先[在没有联网的电脑上建立账户](#使用电脑设备进行操作)。为了进一步保障安全，你可以在签署交易前用以下命令对参数进行检查。 
+
+```bash
+cat unsignedTx.json
+```
+
+现在，通过以下命令对交易签名：
+
+```bash
+gaiacli tx sign unsignedTx.json --from-addr <delegatorAddr>> signedTx.json
+```
+
+复制 `signedTx.json` 并转移回联网的那台电脑。最后，用以下命令向网络广播交易。 
+
+```bash
+gaiacli tx broadcast signedTx.json
+```
diff --git a/docs/translations/cn/gaia/deploy-testnet.md b/docs/translations/cn/gaia/deploy-testnet.md
new file mode 100644
index 000000000..f9e959b9d
--- /dev/null
+++ b/docs/translations/cn/gaia/deploy-testnet.md
@@ -0,0 +1,258 @@
+# 部署你自己的测试网
+
+这篇文章介绍了三种创建`gaiad`节点的测试网的方式，每种针对不同的使用场景：
+
+1. 单节点，本地的，手动的测试网
+2. 多节点，本地的，自动的测试网
+3. 多节点，远程的，自动的测试网
+
+支持代码可以在[networks目录](https://github.com/cosmos/cosmos-sdk/tree/develop/networks)中找到，还可以在`local`或`remote`子目录中找到。
+
+> 注意：`remote`网络引导教程可能与最新版本不同步，不可完全依赖。
+
+## 可获取的Docker镜像
+
+如果你需要使用或部署gaia作为容器，你可以跳过`build`步骤并使用官方镜像，$TAG标识你感兴趣的版本：
+
++ `docker run -it -v ~/.gaiad:/root/.gaiad -v ~/.gaiacli:/root/.gaiacli tendermint:$TAG gaiad init`
++ `docker run -it -p 26657:26657 -p 26656:26656 -v ~/.gaiad:/root/.gaiad -v ~/.gaiacli:/root/.gaiacli tendermint:$TAG gaiad start`
++ ...
++ `docker run -it -v ~/.gaiad:/root/.gaiad -v ~/.gaiacli:/root/.gaiacli tendermint:$TAG gaiacli version`
+
+相同的镜像也可以用于构建你自己的docker-compose栈
+
+## 单节点，本地的，手动的测试网
+
+本教程可帮助你创建一个在本地运行网络的验证人节点，以进行测试和其他相关的用途。
+
+### 需要
++ [安装gaia](./installation.md)
++ [安装`jq`](https://stedolan.github.io/jq/download/)(可选的)
+
+### 创建genesis文件并启动网络
+
+```bash
+# You can run all of these commands from your home directory
+cd $HOME
+
+# Initialize the genesis.json file that will help you to bootstrap the network
+gaiad init --chain-id=testing testing
+
+# Create a key to hold your validator account
+gaiacli keys add validator
+
+# Add that key into the genesis.app_state.accounts array in the genesis file
+# NOTE: this command lets you set the number of coins. Make sure this account has some coins
+# with the genesis.app_state.staking.params.bond_denom denom, the default is staking
+gaiad add-genesis-account $(gaiacli keys show validator -a) 1000000000stake,1000000000validatortoken
+
+# Generate the transaction that creates your validator
+gaiad gentx --name validator
+
+# Add the generated bonding transaction to the genesis file
+gaiad collect-gentxs
+
+# Now its safe to start `gaiad`
+gaiad start
+```
+
+启动将会把`gaiad`相关的所有数据放在`~/.gaiad`目录。你可以检查所创建的genesis文件——`~/.gaiad/config/genesis.json`。同时`gaiacli`也已经配置完成并且有了一个拥有token的账户(stake和自定义的代币)。
+
+## 多节点，本地的，自动的测试网
+
+在[networks/local目录](https://github.com/cosmos/cosmos-sdk/tree/develop/networks/local)中运行如下命令:
+
+### 需要
++ [安装gaia](./installation.md)
++ [安装docker](https://docs.docker.com/install/)
++ [安装docker-compose](https://docs.docker.com/compose/install/)
+
+
+### 编译
+
+编译`gaiad`二进制文件(linux)和运行`localnet`命令所需的`tendermint/gaianode` docker images。这个二进制文件将被安装到container中，并且可以更新重建image，因此您只需要构建一次image。
+
+```
+# Work from the SDK repo
+cd $GOPATH/src/github.com/cosmos/cosmos-sdk
+
+# Build the linux binary in ./build
+make build-linux
+
+# Build tendermint/gaiadnode image
+make build-docker-gaiadnode
+```
+
+### 运行你的测试网
+
+运行一个拥有4个节点的测试网络:
+
+```bash
+make localnet-start
+```
+
+此命令使用gaiadnode image创建了一个4节点网络。每个节点的端口可以在下表中找到：
+
+| `Node ID` | `P2P Port` | `RPC Port` |
+| ----- | ----- | ---- |
+| `gaianode0` | `26656` | `26657` |
+| `gaianode1` | `26659` | `26660` |
+| `gaianode2` | `26661` | `26662` |
+| `gaianode3` | `26663` | `26664` |
+
+更新可执行程序，只需要重新编译并重启节点:
+
+```bash
+make build-linux localnet-start
+```
+
+### 配置
+
+`make localnet-start`命令通过调用`gaiad testnet`命令在`./build`中创建了一个4节点测试网络的文件。输出`./build`目录下一些文件:
+
+```bash
+$ tree -L 2 build/
+build/
+├── gaiacli
+├── gaiad
+├── gentxs
+│   ├── node0.json
+│   ├── node1.json
+│   ├── node2.json
+│   └── node3.json
+├── node0
+│   ├── gaiacli
+│   │   ├── key_seed.json
+│   │   └── keys
+│   └── gaiad
+│       ├── ${LOG:-gaiad.log}
+│       ├── config
+│       └── data
+├── node1
+│   ├── gaiacli
+│   │   └── key_seed.json
+│   └── gaiad
+│       ├── ${LOG:-gaiad.log}
+│       ├── config
+│       └── data
+├── node2
+│   ├── gaiacli
+│   │   └── key_seed.json
+│   └── gaiad
+│       ├── ${LOG:-gaiad.log}
+│       ├── config
+│       └── data
+└── node3
+    ├── gaiacli
+    │   └── key_seed.json
+    └── gaiad
+        ├── ${LOG:-gaiad.log}
+        ├── config
+        └── data
+```
+
+每个`./build/nodeN`目录被挂载到对应container的`/gaiad`目录。
+
+### 日志输出
+
+日志被保存在每个`./build/nodeN/gaiad/gaia.log`文件中。你也可以直接通过Docker来查看日志：
+
+```bash
+docker logs -f gaiadnode0
+```
+
+
+### 密钥&账户
+
+你需要使用指定节点的`gaiacli`目录作为你的`home`来同`gaiacli`交互，并执行查询或者创建交易:
+
+```bash
+gaiacli keys list --home ./build/node0/gaiacli
+```
+
+现在账户已经存在了，你可以创建新的账户并向其发送资金！
+
+::: 提示
+注意：每个节点的密钥种子放在`./build/nodeN/gaiacli/key_seed.json`中，可以通过`gaiacli keys add --restore`命令来回复。
+:::
+
+### 特殊的可执行程序
+如果你拥有多个不同名称的可执行程序，则可以使用BINARY环境变量指定要运行的可执行程序。可执行程序的路径是相对于挂载的卷。例如：
+
+```
+# Run with custom binary
+BINARY=gaiafoo make localnet-start
+```
+
+
+## 多节点，远程的，自动的测试网
+
+应该从[networks目录](https://github.com/cosmos/cosmos-sdk/tree/develop/networks)运行下面的命令。
+
+### Terraform & Ansible
+
+使用[Terraform](https://www.terraform.io/)在AWS上创建服务器然后用[Ansible](https://www.ansible.com/)创建并管理这些服务器上的测试网来完成自动部署。
+
+### 前提
+
++ 在一台Linux机器上安装[Terraform](https://www.terraform.io/downloads.html)和[Ansible](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html)
++ 创建一个具有EC2实例创建能力的[ASW API token](https://docs.aws.amazon.com/general/latest/gr/managing-aws-access-keys.html)
++ 创建SSH密钥
+
+```
+export AWS_ACCESS_KEY_ID="2345234jk2lh4234"
+export AWS_SECRET_ACCESS_KEY="234jhkg234h52kh4g5khg34"
+export TESTNET_NAME="remotenet"
+export CLUSTER_NAME= "remotenetvalidators"
+export SSH_PRIVATE_FILE="$HOME/.ssh/id_rsa"
+export SSH_PUBLIC_FILE="$HOME/.ssh/id_rsa.pub"
+```
+
+`terraform`和`ansible`都会使用到。
+
+### 创建一个远程网络
+
+```
+SERVERS=1 REGION_LIMIT=1 make validators-start
+```
+
+测试网络的名称将由`--chain-id`定义，集群的名称则是AWS中服务器管理标识。该代码将在每个可用区中创建服务器数量的服务器，最多为REGION_LIMIT，从us-east-2开始。（us-east-1被排除在外）下面的BaSH脚本也是如此，但更便于输入。
+
+```
+./new-testnet.sh "$TESTNET_NAME" "$CLUSTER_NAME" 1 1
+```
+
+
+### 快速查询状态入口
+
+```
+make validators-status
+```
+
+
+### 删除服务器
+
+```
+make validators-stop
+```
+
+
+### 日志输出
+你可以将日志发送到Logz.io，一个Elastic栈（Elastic搜索，Logstash和Kibana）服务提供商。你可以将节点设置为自动登录。创建一个帐户并从此页面上的说明中获取你的API密钥，然后：
+
+```
+yum install systemd-devel || echo "This will only work on RHEL-based systems."
+apt-get install libsystemd-dev || echo "This will only work on Debian-based systems."
+
+go get github.com/mheese/journalbeat
+ansible-playbook -i inventory/digital_ocean.py -l remotenet logzio.yml -e LOGZIO_TOKEN=ABCDEFGHIJKLMNOPQRSTUVWXYZ012345
+```
+
+
+### 监控
+
+你可以安装DataDog代理：
+
+```
+make datadog-install
+```
\ No newline at end of file
diff --git a/docs/translations/cn/gaia/gaiacli.md b/docs/translations/cn/gaia/gaiacli.md
new file mode 100644
index 000000000..389a32356
--- /dev/null
+++ b/docs/translations/cn/gaia/gaiacli.md
@@ -0,0 +1,723 @@
+# Gaia客户端
+
+## Gaia CLI
+
+::: 注意
+如果你收到了下面这条错误消息：
+
+```bash
+Must specify these options: --chain-id  when --trust-node is false
+```
+
+你必须选择是否要验证轻客户端的证明。如果你信任要查询的节点，则可以简单地传递`--trust-node=true` -- 否则你需要指定`--chain-id`。
+:::
+
+`gaiacli`是管理Cosmos测试网上的帐户和交易的命令行操作界面。它的配置文件位于`$HOME/.gaiacli/config/config.toml`中，可以手动编辑或通过`gaiacli config`命令编辑：
+
+```bash
+gaiacli config chain-id cosmoshub-1
+```
+
+有关命令用法的更多信息，请参阅其帮助信息：`gaiacli config --help`。
+
+以下是有用的`gaiacli`命令列表，包括用法示例。
+
+### Key
+
+#### Key类型
+
+有如下类型的key：
+
++ `cosmos` ：通过`gaiacli keys add`
+	+ 从通过`gaiacli keys add`生成的账户私钥中产生
+	+ 用于接收资金
+	+ 例如 `cosmos15h6vd5f0wqps26zjlwrc6chah08ryu4hzzdwhc`
++ `cosmosvaloper`
+	+ 用于关联一个验证人和其操作者
+	+ 用于发起staking操作命令
+	+ 例如 `cosmosvaloper1carzvgq3e6y3z5kz5y6gxp3wpy3qdrv928vyah`
++ `cosmospub`
+	+ 从通过`gaiacli keys add`生成的账户私钥中产生
+	+ 例如 `cosmospub1zcjduc3q7fu03jnlu2xpl75s2nkt7krm6grh4cc5aqth73v0zwmea25wj2hsqhlqzm`
++ `cosmosvalconspub`
+	+ 在使用`gaiad init`创建节点时生成
+	+ 使用`gaiad tendermint show-validator`获得该值
+	+ 例如 `cosmosvalconspub1zcjduepq0ms2738680y72v44tfyqm3c9ppduku8fs6sr73fx7m666sjztznqzp2emf`
+
+#### 生成key
+
+你需要一个帐户的私钥公钥对（分别称作`sk`，`pk`）才能接收资金，发送交易，绑定交易等等。
+
+生成一个新的*secp256k1*密钥：
+
+```bash
+gaiacli keys add <account_name>
+```
+
+接下来，你必须创建一个密码来保护磁盘上的密钥。上述命令的输出将包含种子短语。建议将种子短语保存在安全的地方，以便在忘记密码的情况下，最终可以使用以下命令从种子短语重新生成密钥：
+
+```bash
+gaiacli keys add --recover
+```
+
+如果你检查你的私钥，你会看到`<account_name>` :
+
+```bash
+gaiacli keys show <account_name>
+```
+
+通过下面的命令查看验证人操作者的地址：
+
+```bash
+gaiacli keys show <account_name> --bech=val
+```
+
+你可以查看你所有的可以使用的密钥：
+
+```bash
+gaiacli keys list
+```
+
+查看你节点的验证人公钥：
+
+```bash
+gaiad tendermint show-validator
+```
+
+请注意，这是Tendermint的签名密钥，而不是你在委托交易中使用的操作员密钥。
+
+::: 警告
+我们强烈建议不要对多个密钥使用相同的密码。Tendermint团队和Interchain Foundation将不承担资金损失的责任。
+:::
+
+#### 生成多签公钥
+你可以生成一个多签公钥并将其打印：
+
+```bash
+gaiacli keys add --multisig=name1,name2,name3[...] --multisig-threshold=K new_key_name
+```
+
+`K`是将要对多签公钥发起的交易进行签名的最小私钥数。
+
+`--multisig`标识必须包含要将组合成一个公钥的那些子公钥的名称，该公钥将在本地数据库中生成并存储为`new_key_name`。通过`--multisig`提供的所有名称必须已存在于本地数据库中。除非设置了`--nosort`标识，否则在命令行上提供密钥的顺序无关紧要，即以下命令生成两个相同的密钥：
+
+```bash
+gaiacli keys add --multisig=foo,bar,baz --multisig-threshold=2 multisig_address
+gaiacli keys add --multisig=baz,foo,bar --multisig-threshold=2 multisig_address
+```
+
+多签地址也可以在运行中生成并通过以下命令打印：
+
+```bash
+gaiacli keys show --multisig-threshold K name1 name2 name3 [...]
+```
+
+有关如何生成多签帐户，使用其签名和广播多签交易的详细信息，请参阅[多签交易]()
+
+### fee和gas
+
+每笔交易可能会提供fee或gas price，但不能同时提供。大多数用户通常会提供fee，因为这是你将为最终被记入帐本中的交易提供的费用。
+
+验证人可以配置最低gas price（多币种的），并且在决定它们是否能被包含在区块中的`CheckTx`期间使用改值，其中 `gasPrices >= minGasPrices`。请注意，你的交易必须提供大于或等于验证人要求的任何接受币种的费用。
+
+注意：有了这样的机制，验证人可能会开始在mempool中通过gasPrice来优先处理某些txs，因此提供更高fee或gas price可能会产生更高的tx优先级。
+
+比如：
+
+```bash
+gaiacli tx send ... --fees=100photino
+```
+
+或：
+
+```bash
+gaiacli tx send ... --gas-prices=0.000001stake
+```
+
+
+### 账户
+
+#### 获取token
+
+获取token的最佳方式是通过[Cosmos测试网水龙头](https://faucetcosmos.network)。如果水龙头对你不生效，尝试在[#cosmos-validator](https://riot.im/app/#/room/#cosmos-validators:matrix.org)上向人索要。水龙头需要你打算用于抵押股权的`cosmos`开头的地址。
+
+#### 查询账户余额
+
+在你的地址收到token后，你可以通过以下命令查看账户的余额：
+
+```bash
+gaiacli query account <account_cosmos>
+```
+
+::: 注意
+当你查询余额为零的帐户时，你将收到以下错误：`No account with address <account_cosmos> was found in the state.` 如果你在节点与区块链完全同步之前就查询，也会发生这种情况。这些都很正常。
+:::
+
+#### 发送token
+
+你可以通过如下命令从一个账户发送资金到另一个账户：
+
+```bash
+gaiacli tx send <destination_cosmos> 10faucetToken \
+  --chain-id=<chain_id> \
+  --from=<key_name> \
+```
+
+::: 注意
+`--amount`标识接收格式：`--amount=<value|coin_name>`
+:::
+
+::: 注意
+你可能希望通过`--gas`标识限制交易可以消耗的最大燃料。如果你通过`--gas=auto`，将在执行交易前自动估gas。gas估算可能是不准确的，因为状态变化可能发生在模拟结束和交易的实际执行之间，因此在原始估计之上应用调整以确保能够成功地广播交易。可以通过`--gas-adjustment`标识控制调整，其默认值为1.0。
+:::
+
+现在，查看源账户和目标账户的更新后的余额：
+
+```bash
+gaiacli query account <account_cosmos>
+gaiacli query account <destination_cosmos>
+```
+
+你还可以使用`--block`标识查询在特定高度区块下你的余额：
+
+```bash
+gaiacli query account <account_cosmos> --block=<block_height>
+```
+
+你可以通过在命令行中附加`--dry-run`标识来模拟交易而不实际广播它：
+
+```bash
+gaiacli tx send <destination_cosmosaccaddr> 10faucetToken \
+  --chain-id=<chain_id> \
+  --from=<key_name> \
+  --dry-run
+```
+
+此外，你可以通过将`--generate-only`附加到命令行参数列表来构建交易并将其JSON格式打印到STDOUT：
+
+```bash
+gaiacli tx send <destination_cosmosaccaddr> 10faucetToken \
+  --chain-id=<chain_id> \
+  --from=<key_name> \
+  --generate-only > unsignedSendTx.json
+```
+
+```bash
+gaiacli tx sign \
+  --chain-id=<chain_id> \
+  --from=<key_name>
+  unsignedSendTx.json > signedSendTx.json
+```
+
+你可以通过下面的命令验证交易的签名：
+
+```bash
+gaiacli tx sign --validate-signatures signedSendTx.json
+```
+
+你可以将由JSON文件提供的已签名的交易广播至指定节点：
+
+```bash
+gaiacli tx broadcast --node=<node> signedSendTx.json
+```
+
+### 查询交易
+
+#### 匹配一组tag
+
+你可以使用交易搜索命令查询与每个交易上添加的特定`标签集`匹配的交易。
+
+每个标签都由`<tag>:<value>`形式的键值对形成。还可以使用`＆`符号组合标签来查询更具体的结果。
+
+使用`标签`查询交易的命令如下：
+
+```bash
+gaiacli query txs --tags='<tag>:<value>'
+```
+
+使用多个`标签`:
+
+```bash
+gaiacli query txs --tags='<tag1>:<value1>&<tag2>:<value2>'
+```
+
+通过`page`和`limit`来实现分页:
+
+```bash
+gaiacli query txs --tags='<tag>:<value>' --page=1 --limit=20
+```
+
+::: 注意
+action标签始终等于相关message的Type()函数返回的消息类型。
+
+你可以在每个SDK的模块中找到目前的标签列表：
++ [Common tags](https://github.com/cosmos/cosmos-sdk/blob/d1e76221d8e28824bb4791cb4ad8662d2ae9051e/types/tags.go#L57-L63)
++ [Staking tags](https://github.com/cosmos/cosmos-sdk/blob/master/x/staking/tags/tags.go#L8-L24)
++ [Governance tags](https://github.com/cosmos/cosmos-sdk/blob/master/x/gov/tags/tags.go#L8-L24)
++ [Slashing tags](https://github.com/cosmos/cosmos-sdk/blob/master/x/slashing/tags/tags.go#L8-L24)
++ [Distribution tags](https://github.com/cosmos/cosmos-sdk/blob/master/x/distribution/tags/tags.go#L8-L24)
++ [Bank tags](https://github.com/cosmos/cosmos-sdk/blob/master/x/bank/tags.go#L8-L24)
+:::
+
+#### 匹配一笔交易的hash
+
+你一可以通过指定hash值查询该笔交易：
+
+```bash
+gaiacli query tx [hash]
+```
+
+### Slashing
+
+#### Unjailing
+
+将你入狱的验证人释放出狱：
+
+```bash
+gaiacli tx slashing unjail --from <validator-operator-addr>
+```
+
+#### Signing Info
+
+检索一个验证人的签名信息：
+
+```bash
+gaiacli query slashing signing-info <validator-pubkey>
+```
+
+
+#### 查询参数
+
+你可以查询当前的slashing参数：
+
+```bash
+gaiacli query slashing params
+```
+
+### Staking
+
+#### 设置一个验证人
+
+有关如何设置验证人候选者的完整指南，请参阅[验证人设置]()章节
+
+#### 向一个验证人委托
+
+一旦主网上线，你可以把`atom`委托给一个验证人。这些委托人可以收到部分验证人的收益。阅读[Cosmos Token Model](https://github.com/cosmos/cosmos/raw/master/Cosmos_Token_Model.pdf)了解更多信息。
+
+#### 查询验证人
+
+你可以查询指定链的验证人：
+
+```bash
+gaiacli query staking validators
+```
+
+如果你想要获得单个验证人的信息，你可以使用下面的命令：
+
+```bash
+gaiacli query staking validator <account_cosmosval>
+```
+
+#### 绑定token
+
+在Cosmos Hub主网中，我们绑定`uatom`，`1atom = 1000000uatom`。你可以把token绑定在一个测试网验证人节点上（即委托）：
+
+```bash
+gaiacli tx staking delegate \
+  --amount=10000000uatom \
+  --validator=<validator> \
+  --from=<key_name> \
+  --chain-id=<chain_id>
+```
+
+`<validator>`是你要委托的验证人的操作者地址。如果你运行的是本地testnet，可以通过以下方式找到：
+
+```bash
+gaiacli keys show [name] --bech val
+```
+
+其中`[name]`是初始化`gaiad`时指定的键的名称。
+
+虽然token是绑定的，但它们与网络中的所有其他绑定的token汇集在一起。验证人和委托人获得一定比例的股权，这些股权等于他们在这个资产池中的抵押。
+
+#### 查询委托
+
+一旦提交了一笔对验证人的委托，你可以使用下面的命令查看委托详情：
+
+```bash
+gaiacli query staking delegation <delegator_addr> <validator_addr>
+```
+
+或者你想查看所有当前的委托：
+
+```bash
+gaiacli query staking delegations <delegator_addr>
+```
+
+你还可以通过添加`--height`标识来获取先前的委托状态。
+
+#### 解绑token
+如果出于一些原因验证人行为异常，或者你想解绑一定数量的token，请使用以下命令。你可以使用相应的`shares-amount`标识（例如：`12.1`）或`shares-fraction`（例如：`0.25`）来解绑。
+
+```bash
+gaiacli tx staking unbond \
+  --validator=<account_cosmosval> \
+  --shares-fraction=0.5 \
+  --from=<key_name> \
+  --chain-id=<chain_id>
+```
+
+经过解绑期后，解绑自动完成。
+
+#### 查询Unbonding-Delegations
+
+一旦你开始了一笔unbonding-delegation，你可以使用以下命令查看信息：
+
+```bash
+gaiacli query staking unbonding-delegation <delegator_addr> <validator_addr>
+```
+
+或者你可以查看当前你所有的unbonding-delegation:
+
+```bash
+gaiacli query staking unbonding-delegations <account_cosmos>
+```
+
+此外，你可以从特定验证人获取所有unbonding-delegation：
+
+```bash
+gaiacli query staking unbonding-delegations-from <account_cosmosval>
+```
+
+要获取指定区块时的unbonding-delegation状态，请尝试添加`--height`标识。
+
+#### 重新委托token
+
+重新授权是一种委托类型，允许你将非流动token从一个验证人上绑定到另一个验证人：
+
+```bash
+gaiacli tx staking redelegate \
+  --addr-validator-source=<account_cosmosval> \
+  --addr-validator-dest=<account_cosmosval> \
+  --shares-fraction=50 \
+  --from=<key_name> \
+  --chain-id=<chain_id>
+```
+
+这里，你还可以使用`shares-amount`或`shares-fraction`标识重新委托。
+
+经过解绑期后，重新委托自动完成。
+
+#### 查询重新委托
+
+开始重新授权后，你可以使用以下命令查看其信息：
+
+```bash
+gaiacli query staking redelegation <delegator_addr> <src_val_addr> <dst_val_addr>
+```
+
+或者，如果你可以检查所有当前的unbonding-delegation：
+
+```bash
+gaiacli query staking redelegations <account_cosmos>
+```
+
+此外，你可以查询某个特定验证人的所有转出的重新绑定：
+
+```bash
+gaiacli query staking redelegations-from <account_cosmosval>
+```
+
+添加`--height`标识来查询之前某个特定区块的redelegation。
+
+#### 查询参数
+
+参数定义了staking的高级参数。你可以使用以下方法获取：
+
+```bash
+gaiacli query staking params
+```
+
+使用上面的命令，你将获得以下值：
+
++ unbonding时间
++ 验证人的最大数量
++ 用于抵押的币种
+
+所有这些值都将通过对一个`ParameterChange`提案的`governance`流程进行更新。
+
+#### 查询抵押池
+一个抵押池定义了当前状态的动态参数。你可以通过以下命令查询：
+
+```bash
+gaiacli query staking pool
+```
+
+使用`pool`命令，你将获得以下值：
+
++ 未绑定和已绑定的token
++ token总量
++ 当前的年度通货膨胀率以及上次发生通货膨胀的区块
++ 最后记录的绑定股权
+
+#### 查询对验证人的绑定
+你可以查询对某个验证人的所有绑定：
+
+```bash
+gaiacli query delegations-to <account_cosmosval>
+```
+
+### 治理
+
+治理是Cosmos Hub的用户可以就软件升级，主网的参数或自定义文本提案并达成共识的过程。这是通过对提案进行投票来完成的，提案将由主要网络上的`Atom`持有者提交。
+
+关于投票过程的一些考虑因素：
++ 投票由绑定`Atom`的持有者以1个绑定的`Atom`对应1票方式投出
++ 委托人不投票的话会将票权继承给其验证人
++ **验证人必须对每个提案进行投票**。如果验证人未对提案进行投票，则会对其进行削减处罚。
++ 投票期结束时（主网上是2周）统计投票。每个地址可以多次投票以更新其`Option`值（每次支付交易费用），只有最后一次投票将被视为有效。
++ 选民可以选择`Yes`，`No`，`NoWithVeto`和`Abstain`选项。在投票结束时，如果`( YesVotes / ( YesVotes + NoVotes + NoWithVetoVotes ) ) > 1/2`且`( NoWithVetoVotes / ( YesVotes + NoVotes + NoWithVetoVotes )) < 1/3`提案通过，否则就拒绝。
+
+有关治理流程及其工作原理的更多信息，请查看Governance模块[规范]()。
+
+#### 创建一个治理提案
+
+要创建治理提案，你必须提交初始存款以及提案详细信息：
++ `title` : 提案的标题
++ `description` : 提案的描述
++ `type` : 提案类型。值必须是 *Text*（目前还不支持*SoftwareUpgrade*和*ParameterChange*类型）。
+
+```bash
+gaiacli tx gov submit-proposal \
+  --title=<title> \
+  --description=<description> \
+  --type=<Text/ParameterChange/SoftwareUpgrade> \
+  --deposit=<40steak> \
+  --from=<name> \
+  --chain-id=<chain_id>
+```
+
+#### 查询提案
+
+一旦创建，你就可以查询提案的信息：
+
+```bash
+gaiacli query gov proposal <proposal_id>
+```
+
+或者查询所有的有效提案：
+
+```bash
+gaiacli query gov proposals
+```
+
+你还可以使用`voter`或`depositor`标识来过滤查询提案。
+
+要查询特定提案的提议人：
+
+```bash
+gaiacli query gov proposer <proposal_id>
+```
+
+#### 增加存入金
+
+为了将提案广播到网络，存入的金额必须高于`minDeposit`值（默认值：`10steak`）。如果你之前创建的提案不符合此要求，你仍可以增加存入的总金额以激活它。达到最低存入金后，提案进入投票期：
+
+```bash
+gaiacli tx gov deposit <proposal_id> <200steak> \
+  --from=<name> \
+  --chain-id=<chain_id>
+```
+
+> 注意：达到`MaxDepositPeriod`后，将删除不符合此要求的提案。
+
+
+#### 查询存入金
+创建新提案后，你可以查询提交其所有存款：
+
+```bash
+gaiacli query gov deposits <proposal_id>
+```
+
+你还可以查询特定地址提交的存入金：
+
+```bash
+gaiacli query gov deposit <proposal_id> <depositor_address>
+```
+
+#### 投票给一个提案
+
+在提案的存入金达到`MinDeposit`后，投票期将开放。抵押了`Atom`的持有人可以投票：
+
+```bash
+gaiacli query gov vote <proposal_id> <voter_address>
+```
+
+你还可以查询提交给所有此前投给指定提案的投票：
+
+```bash
+gaiacli query gov votes <proposal_id>
+```
+
+#### 查询提案的计票结果
+
+要检查指定提案的当前计票，你可以使用`tally`命令：
+
+```bash
+gaiacli query gov tally <proposal_id>
+```
+
+#### 查询治理参数
+
+要检查当前的治理参数，请运行：
+
+```bash
+gaiacli query gov params
+```
+
+查询运行的治理参数的子集：
+
+```bash
+gaiacli query gov param voting
+gaiacli query gov param tallying
+gaiacli query gov param deposit
+```
+
+### 费用分配
+
+#### 查询分配参数
+
+查询当前的分配参数：
+
+```bash
+gaiacli query distr params
+```
+
+#### 查询
+
+查询当前未结算的（未提取）的奖励：
+
+```bash
+gaiacli query distr outstanding-rewards
+```
+
+#### 查询验证人佣金
+
+查询对一个验证人的未结算的佣金：
+
+```bash
+gaiacli query distr commission <validator_address>
+```
+
+#### 查询验证人的削减处罚
+
+查询一个验证人的处罚历史记录：
+
+```bash
+gaiacli query distr slashes <validator_address> <start_height> <end_height>
+```
+
+#### 查询委托人奖励
+
+查询某笔委托当前的奖励（如果要取回）：
+
+```bash
+gaiacli query distr rewards <delegator_address> <validator_address>
+```
+
+#### 查询所有的委托人奖励
+
+要查询委托人的所有当前奖励（如果要取回），请运行：
+
+```bash
+gaiacli query distr rewards <delegator_address>
+```
+
+### 多签交易
+
+多签交易需要多个私钥的签名。因此，从多签账户生成和签署交易涉及有关各方之间的合作。密钥持有者的任何一方都可以发起多签，并且至少要有其中一方需要将其他账户的公钥导入到本地的数据库并生成多签公钥来完成和广播该笔交易。
+
+例如，给定包含密钥`p1`，`p2`和`p3`的多签密钥，每个密钥由不同方持有，持有`p1`的用户将需要导入`p2`和`p3`的公钥以生成多签帐户公钥：
+
+```bash
+gaiacli keys add \
+  --pubkey=cosmospub1addwnpepqtd28uwa0yxtwal5223qqr5aqf5y57tc7kk7z8qd4zplrdlk5ez5kdnlrj4 \
+  p2
+
+gaiacli keys add \
+  --pubkey=cosmospub1addwnpepqgj04jpm9wrdml5qnss9kjxkmxzywuklnkj0g3a3f8l5wx9z4ennz84ym5t \
+  p3
+
+gaiacli keys add \
+  --multisig-threshold=2
+  --multisig=p1,p2,p3
+  p1p2p3
+```
+
+已存储新的多签公钥`p1p2p3`，其地址将用作多签交易的签名者：
+
+```bash
+gaiacli keys show --address p1p2p3
+```
+
+创建多签交易的第一步是使用上面创建的多签地址初始化：
+
+```bash
+gaiacli tx send cosmos1570v2fq3twt0f0x02vhxpuzc9jc4yl30q2qned 10000000uatom \
+  --from=<multisig_address> \
+  --generate-only > unsignedTx.json
+```
+
+`unsignedTx.json`文件包含以JSON编码的未签署交易。`p1`现在可以使用自己的私钥对交易进行签名：
+
+```bash
+gaiacli tx sign \
+  --multisig=<multisig_address> \
+  --name=p1 \
+  --output-document=p1signature.json \
+  unsignedTx.json
+```
+
+生成签名后，`p1`将`unsignedTx.json`和`p1signature.json`都发送到`p2`或`p3`，然后`p2`或`p3`将生成它们各自的签名:
+
+```bash
+gaiacli tx multisign \
+  unsignedTx.json \
+  p1p2p3 \
+  p1signature.json p2signature.json > signedTx.json
+```
+
+现在可以把交易发送给节点：
+
+```bash
+gaiacli tx broadcast signedTx.json
+```
+
+## shell完全脚本
+
+可以通过完全命令生成主流的UNIX shell解释器（如`Bash`和`Zsh`）的`completion`命令，该命令可用于`gaiad`和`gaiacli`。
+
+如果要生成Bash完成脚本，请运行以下命令：
+
+```bash
+gaiad completion > gaiad_completion
+gaiacli completion > gaiacli_completion
+```
+
+如果要生成Zsh完成脚本，请运行以下命令：
+
+```bash
+gaiad completion --zsh > gaiad_completion
+gaiacli completion --zsh > gaiacli_completion
+```
+
+::: 注意
+在大多数UNIX系统上，可以在`.bashrc`或`.bash_profile`中加载此类脚本以启用Bash自动完成：
+
+```
+echo '. gaiad_completion' >> ~/.bashrc
+echo '. gaiacli_completion' >> ~/.bashrc
+```
+
+有关如何启用shell自动完成的信息，请参阅操作系统提供的解释器用户手册。
+:::
\ No newline at end of file
diff --git a/docs/translations/cn/gaia/genesis.md b/docs/translations/cn/gaia/genesis.md
new file mode 100644
index 000000000..c0cc197ea
--- /dev/null
+++ b/docs/translations/cn/gaia/genesis.md
@@ -0,0 +1,48 @@
+# Gaia的创世状态
+
+`GenesisState`是Gaia的创世状态，由账户，不同模块的状态和例如创世交易这样的数据组成。每个模块可以指定自己的`GenesisState`，还有每个模块可以指定对创世状态的验证，导入和导出。
+
+Gaia的创世状态有如下定义:
+
+```go
+type GenesisState struct {
+  Accounts     []GenesisAccount      `json:"accounts"`
+  AuthData     auth.GenesisState     `json:"auth"`
+  BankData     bank.GenesisState     `json:"bank"`
+  StakingData  staking.GenesisState  `json:"staking"`
+  MintData     mint.GenesisState     `json:"mint"`
+  DistrData    distr.GenesisState    `json:"distr"`
+  GovData      gov.GenesisState      `json:"gov"`
+  SlashingData slashing.GenesisState `json:"slashing"`
+  GenTxs       []json.RawMessage     `json:"gentxs"`
+}
+```
+
+在gaia的ABCI接口`initChainer`的定义中`initFromGenesisState`被调用，它在内部调用每个模块的`InitGenesis`，提供各自的`GenesisState`作为参数
+
+## 账户
+
+`GenesisState`中的创世账户有如下定义:
+
+```go
+type GenesisAccount struct {
+  Address       sdk.AccAddress `json:"address"`
+  Coins         sdk.Coins      `json:"coins"`
+  Sequence      uint64         `json:"sequence_number"`
+  AccountNumber uint64         `json:"account_number"`
+
+  // vesting account fields
+  OriginalVesting  sdk.Coins `json:"original_vesting"`  // total vesting coins upon initialization
+  DelegatedFree    sdk.Coins `json:"delegated_free"`    // delegated vested coins at time of delegation
+  DelegatedVesting sdk.Coins `json:"delegated_vesting"` // delegated vesting coins at time of delegation
+  StartTime        int64     `json:"start_time"`        // vesting start time (UNIX Epoch time)
+  EndTime          int64     `json:"end_time"`          // vesting end time (UNIX Epoch time)
+}
+```
+
+每个账户必须有一个合理的并唯一的account number，还要有sequence number和address。
+
+账户也可以是锁定账户，必须提供必要的锁定信息。锁定账户必须提供一个最小的`OriginalVesting`和`EndTime`。如果`StartTime`也提供了，这个账户将会被当做一个连续的锁定账户，将按照预定的时间线锁定代币。提供的`StartTime`必须小于`EndTime`，但可以是将来的某个时间。换句话说，`StartTime`不必小于创世时间。当一条新链从一个新状态（不是到处的）生成时，`OriginalVesting` 必须要小于`Coins`
+
+<!-- TODO: Remaining modules and components in GenesisState -->
+
diff --git a/docs/translations/cn/gaia/installation.md b/docs/translations/cn/gaia/installation.md
new file mode 100644
index 000000000..932ae6a52
--- /dev/null
+++ b/docs/translations/cn/gaia/installation.md
@@ -0,0 +1,66 @@
+## 安装Gaia
+
+本教程将详细说明如何在你的系统上安装`gaiad`和`gaiacli`。安装后，你可以作为[全节点](./join-mainnet.md)或是[验证人节点](./validators/validator-setup.md)加入到主网。
+
+### 安装Go
+
+按照[官方文档](https://golang.org/doc/install)安装`go`。记得设置环境变量`$GOPATH`,`$GOBIN`和`$PATH`:
+
+```bash
+mkdir -p $HOME/go/bin
+echo "export GOPATH=$HOME/go" >> ~/.bash_profile
+echo "export GOBIN=\$GOPATH/bin" >> ~/.bash_profile
+echo "export PATH=\$PATH:\$GOBIN" >> ~/.bash_profile
+source ~/.bash_profile
+```
+
+::: 提示
+Cosmos SDK需要安装**Go 1.12.1+**
+:::
+
+### 安装二进制执行程序
+
+接下来，安装最新版本的Gaia。这里我们使用`master`分支，包含了最新的稳定发布版本。如果需要，请通过`git checkout`命令确定是正确的[发布版本](https://github.com/cosmos/cosmos-sdk/releases)。
+
+::: 警告
+对于主网，请确保你的版本大于或等于`v0.33.0`
+:::
+
+```bash
+mkdir -p $GOPATH/src/github.com/cosmos
+cd $GOPATH/src/github.com/cosmos
+git clone https://github.com/cosmos/cosmos-sdk
+cd cosmos-sdk && git checkout master
+make tools install
+```
+
+> *注意*: 如果在这一步中出现问题，请检查你是否安装的是Go的最新稳定版本。
+
+等`gaiad`和`gaiacli`可执行程序安装完之后，请检查:
+
+```bash
+$ gaiad version --long
+$ gaiacli version --long
+```
+
+`gaiacli`的返回应该类似于：
+
+```
+cosmos-sdk: 0.33.0
+git commit: 7b4104aced52aa5b59a96c28b5ebeea7877fc4f0
+vendor hash: 5db0df3e24cf10545c84f462a24ddc61882aa58f
+build tags: netgo ledger
+go version go1.12 linux/amd64
+```
+
+##### Build Tags
+
+build tags指定了可执行程序具有的特殊特性。
+
+| Build Tag | Description                                     |
+| --------- | ----------------------------------------------- |
+| netgo     | Name resolution will use pure Go code           |
+| ledger    | 支持Ledger设备(硬件钱包) |
+
+### 接下来
+然后你可以选择 加入公共测试网 或是 创建私有测试网。
\ No newline at end of file
diff --git a/docs/translations/cn/gaia/join-mainnet.md b/docs/translations/cn/gaia/join-mainnet.md
new file mode 100644
index 000000000..7627c7f0f
--- /dev/null
+++ b/docs/translations/cn/gaia/join-mainnet.md
@@ -0,0 +1,148 @@
+## 加入主网
+
+::: 提示
+请查看[launch repo](https://github.com/cosmos/launch)获取主网信息，包含了所使用的Cosmos-SDK的正确版本和genesis文件。
+:::
+
+::: 警告
+**在更进一步之前你需要[安装gaia](./installation.md)**
+:::
+
+## 创建一个新节点
+
+这些指令适用于从头开始设置一个全节点。
+
+首先，初始化节点并创建必要的配置文件：
+
+```bash
+gaiad init <your_custom_moniker>
+```
+
+::: 注意
+moniker只能包含ASCII字符。使用Unicode字符会使得你的节点不可访问
+:::
+
+你可以稍后在`~/.gaiad/config/config.toml`文件中编辑`moniker`:
+
+```toml
+# A custom human readable name for this node
+moniker = "<your_custom_moniker>"
+```
+
+你可以编辑`~/.gaiad/config/config.toml`文件来开启垃圾交易过滤机制以拒绝收到的手续费过低的交易：
+
+```
+# This is a TOML config file.
+# For more information, see https://github.com/toml-lang/toml
+
+##### main base config options #####
+
+# The minimum gas prices a validator is willing to accept for processing a
+# transaction. A transaction's fees must meet the minimum of any denomination
+# specified in this config (e.g. 10uatom).
+
+minimum-gas-prices = ""
+```
+
+你的全节点已经初始化成功！
+
+## Genesis & Seeds
+
+### 复制genesis文件
+
+将主网的`genesis.json`文件放置在`gaiad`的配置文件夹中
+
+```bash
+mkdir -p $HOME/.gaiad/config
+curl https://raw.githubusercontent.com/cosmos/launch/master/genesis.json > $HOME/.gaiad/config/genesis.json
+```
+
+注意我们使用了[launch repo](https://github.com/cosmos/launch)中的`latest`文件夹，该文件夹包含了最新版本主网的详细信息。
+
+::: 提示
+如果你想加入的是公共测试网，点击[这里](./join-testnet.md)
+:::
+
+运行命令验证配置的正确性:
+
+```bash
+gaiad start
+```
+
+### 添加种子节点
+
+你的节点需要知道如何寻找伙伴节点。你需要添加有用的种子节点到`$HOME/.gaiad/config/config.toml`文件中。[`launch`](https://github.com/cosmos/launch) repo包含了一些种子节点的链接。
+
+如果这些种子节点不再运行，你可以在Cosmos Hub浏览器(可以在[launch page](https://cosmos.network/launch)中找到)发现种子节点和持久节点。
+
+你还可以到[验证人Riot聊天室](https://riot.im/app/#/room/#cosmos-validators:matrix.org)里询问可用节点。
+
+你可以阅读[这里](https://github.com/tendermint/tendermint/blob/develop/docs/tendermint-core/using-tendermint.md#peers)了解更多伙伴节点和种子节点的信息。
+
+::: 警告
+在Cosmos Hub主网中，可接受的币种是`uatom`,`1atom = 1.000.000uatom`
+:::
+
+Cosmos Hub网络中的交易需要支付一笔交易手续费以得到处理。手续费支付执行交易所消耗的gas。计算公式如下：
+
+```
+fees = gas * gasPrices
+```
+
+`gas`由交易本身决定。不同的交易需要不同数量的`gas`。一笔交易的`gas`数量在它被执行时计算，但有一种方式可以提前估算，那就是把标识`gas`
+的值设置为`auto`。当然，这只是给出一个预估值。如果你想要确保为交易提供足够的gas，你可以使用`--gas-adjustment`标识来调整预估值(默认是`1.0`)。
+
+`gasPrice`是每个单位`gas`的单价。每个验证人节点可以设置`min-gas-price`，只会把那些`gasPrice`高于自己设置的`min-gas-price`的交易打包。
+
+交易的`fees`是`gas`与`gasPrice`的结果。作为一个用户，你必须输入三者中的两者。更高的`gasPrice`/`fees`，将提高你的交易被打包的机会。
+
+::: 提示
+主网中推荐的`gas-prices`是`0.025uatom`
+:::
+
+## 设置`minimum-gas-prices`
+
+你的全节点可以在交易池中放入未确认的交易。为了保护其免受Spam攻击，最好设置一个`minimum-gas-prices`来过滤交易以决定是否要放入交易池。这个参数可以在`~/.gaiad/config/gaiad.toml`文件中配置。
+
+推荐的初始`minimum-gas-prices`是`0.025uatom`，如果你愿意可以稍后再修改它。
+
+## 运行一个全节点
+
+通过这条命令开始运行全节点：
+
+```bash
+gaiad start
+```
+
+检查一切是否平稳运行中:
+
+```bash
+gaiacli status
+```
+
+使用[Cosmos Explorer](https://cosmos.network/launch)查看网络状态。
+
+## 导出状态
+
+Gaia能够将整个应用程序的状态转存到一个JSON文件中，该文件可以用于分析还可以用作一个新网络的genesis文件。
+
+导出状态:
+
+```bash
+gaiad export > [filename].json
+```
+
+你还可以导出指定高度的状态(处理完指定高度后的状态):
+
+```bash
+gaiad export --height [height] > [filename].json
+```
+
+如果你计划使用导出的状态文件启动一个新网络，导出时要加上`--for-zero-height`标识:
+
+```bash
+gaiad export --height [height] --for-zero-height > [filename].json
+```
+
+## 升级成为验证人节点
+你现在有了一个运行状态的全节点。接下来，你可以升级你的全节点，成为一个Cosmos验证人。排名前100的验证人节点可以向Cosmos Hub提议新的区块。请查看[创建验证人节点](./validators/validator-setup.md)。
\ No newline at end of file
diff --git a/docs/translations/cn/gaia/join-testnet.md b/docs/translations/cn/gaia/join-testnet.md
new file mode 100644
index 000000000..cc1d47aab
--- /dev/null
+++ b/docs/translations/cn/gaia/join-testnet.md
@@ -0,0 +1,59 @@
+# 加入公共测试网
+
+::: 提示 当前测试网
+请查看[testnet repo](https://github.com/cosmos/testnets)获取最新的公共测试网信息，包含了所使用的Cosmos-SDK的正确版本和genesis文件。
+:::
+
+::: 警告
+你需要先完成[安装`gaia`](./installation.md)
+:::
+
+## 创建一个新节点
+
+> 注意：如果你在之前的测试网中运行过一个全节点，请跳至[升级之前的Testnet](#upgrading-from-previous-testnet)。
+
+要创建一个新节点，主网的指令同样适用：
+
++ [加入mainnet](./join-mainnet.md)
++ [部署验证人节点](./validators/validator-setup.md)
+
+只有SDK的版本和genesis文件不同。查看[testnet repo](https://github.com/cosmos/testnets)
+获取测试网的信息，包括Cosmos-SDK正确的版本和genesis文件。
+
+
+## 升级之前的Testnet
+
+这些指令用以把运行过以前测试网络的全节点升级至最新的测试网络。
+
+### 重置数据
+
+首先，移除过期的文件并重置数据：
+
+```bash
+rm $HOME/.gaiad/config/addrbook.json $HOME/.gaiad/config/genesis.json
+gaiad unsafe-reset-all
+```
+
+你的节点现在处于原始状态并保留了最初的`priv_validator.json`文件和`config.toml`文件。如果之前你还有其他的哨兵节点或者全节点，你的节点仍然会连接他们，但是会失败，因为他们还没有升级。
+
+::: 警告
+确保每个节点有一个独一无二的`priv_validator.json`文件。不要从一个旧节点拷贝`priv_validator.json`到多个新的节点。运行两个有着相同`priv_validator.json`文件的节点会导致双签。
+:::
+
+### 升级软件
+
+现在升级软件：
+
+```bash
+cd $GOPATH/src/github.com/cosmos/cosmos-sdk
+git fetch --all && git checkout master
+make update_tools install
+```
+
+::: 提示
+*注意*：如果在这一步出现问题，请检查是否安装了最新稳定版本的Go。
+:::
+
+注意这里我们使用的是包含最新稳定发布版本的`master`分支。请查看[testnet repo](https://github.com/cosmos/testnets)查看哪个版本的测试网需要哪一个Cosmos-SDK版本，在[SDK发布版](https://github.com/cosmos/cosmos-sdk/releases)中对应的详细信息。
+
+你的全节点已经升级成功！
\ No newline at end of file
diff --git a/docs/translations/cn/gaia/keys.md b/docs/translations/cn/gaia/keys.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/docs/translations/cn/gaia/ledger.md b/docs/translations/cn/gaia/ledger.md
new file mode 100644
index 000000000..4334a0cbd
--- /dev/null
+++ b/docs/translations/cn/gaia/ledger.md
@@ -0,0 +1,77 @@
+# Ledger Nano支持
+
+## 关于HD钱包
+
+HD钱包（分层确定性钱包）, 最初是在比特币的[BIP32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)提案中提出,
+是一种特殊的钱包类型，可以让用户从单个种子派生任意数量的账户。为了更好的理解, 让我们定义以下术语：
+
+- **钱包**: 从一个给定的seed中获得的一组账户。
+- **账户**: 一组公钥/私钥对。
+- **私钥**: 私钥是用于签署消息的私密信息。在区块链领域, 一个私钥就是一个账户的所有者。永远不要想他人透露用户的私钥。
+- **公钥**: 公钥是通过对私钥上使用不可逆的加密函数而获得的一条信息。从公钥中可以导出地址。但无法从公钥中逆向获得私钥。
+- **地址**: 地址是一个公开的用于标识账户的，带着可读前缀的字符串。通过对公钥使用加密函数获得。
+- **数字签名**: 数字签名是一段加密信息，证明了指定私钥的所有者在不泄露其私钥的情况下，批准了指定消息。
+- **种子**: 同助记词。
+- **助记词**:  助记符是一串单词，用作种子来派生私钥。助记符是每个钱包的核心。永远不要丢失你的助记词。把它写在一张纸上，然后把它存放在安全的地方。如果你失去了它，那就没有办法去重新获取它了。如果某人获得了助记词访问权限，他们将获得所有相关帐户的访问权限。
+
+HD钱包的核心是种子。用这个种子用户可以确定地生成子帐户。要从种子生成子帐户，使用了单向的数学转换。要决定生成哪个帐户，用户指定`path`，通常是`integer`（`0`，`1`，`2`，...）。
+
+例如，通过将`path`指定为`0`，钱包将从种子生成`0号私钥`。然后，可以从`0号私钥`生成“`号公钥`。最后，可以从`0号公钥`生成`0号地址`。所有这些步骤都是单向的，这意味着`公钥`无法从`地址`中获得，`私钥`无法从`公钥`中获得，......
+
+```
+     Account 0                         Account 1                         Account 2
+
++------------------+              +------------------+               +------------------+
+|                  |              |                  |               |                  |
+|    Address 0     |              |    Address 1     |               |    Address 2     |
+|        ^         |              |        ^         |               |        ^         |
+|        |         |              |        |         |               |        |         |
+|        |         |              |        |         |               |        |         |
+|        |         |              |        |         |               |        |         |
+|        +         |              |        +         |               |        +         |
+|  Public key 0    |              |  Public key 1    |               |  Public key 2    |
+|        ^         |              |        ^         |               |        ^         |
+|        |         |              |        |         |               |        |         |
+|        |         |              |        |         |               |        |         |
+|        |         |              |        |         |               |        |         |
+|        +         |              |        +         |               |        +         |
+|  Private key 0   |              |  Private key 1   |               |  Private key 2   |
+|        ^         |              |        ^         |               |        ^         |
++------------------+              +------------------+               +------------------+
+         |                                 |                                  |
+         |                                 |                                  |
+         |                                 |                                  |
+         +--------------------------------------------------------------------+
+                                           |
+                                           |
+                                 +---------+---------+
+                                 |                   |
+                                 |  Mnemonic (Seed)  |
+                                 |                   |
+                                 +-------------------+
+```
+
+从种子中推导出帐户的过程是确定性的。这意味着给定相同的路径，派生出私钥将始终相同。
+
+存储在帐户中的资金由私钥控制。此私钥对助记词使用单向函数生成的。如果丢失了私钥，则可以使用助记词恢复它。但是，如果丢失了助记词，则将无法访问所有派生的私钥。同样，如果有人获得了你的助记词访问权限，他们就可以访问所有相关帐户。
+
+## Ledger支持HD钱包
+
+在Ledger钱包的内核，有一个用于生成私钥的助记词。初始化Ledger时，会生成助记词。
+
+::: 危险
+**不要遗失或与任何人分享你的12/24个单词。为防止盗窃或资金损失，最好确保备份多个助记词拷贝，并将其存放在安全可靠的地方，并且只有你知道如何访问。如果有人能够访问你的助记词，他们将能够访问你的私钥并控制与其关联的帐户**
+:::
+
+助记词与Cosmos帐户体系兼容。用于在Cosmos Hub网络上生成地址和交易的工具称为`gaiacli`，它支持从Ledger种子派生帐户私钥。请注意，Ledger钱包充当种子和私钥的沙盒，并且对交易进行签名的过程完全在内部进行。没有任何私人信息会离开Ledger钱包。
+
+要将`gaiacli`与Ledger钱包一起使用，你需要具备以下条件：
+
+- [在Ledger Nano中安装`COSMOS`应用并生成账户](./delegator-guide-cli.md#using-a-ledger-device)
+- [有一个你打算连接的可访问的并处于运行状态的`gaiad`实例](./delegator-guide-cli.md#accessing-the-cosmos-hub-network)
+- [一个同你所选的`gaiad`实例相连接的`gaiacli`实例](./delegator-guide-cli.md#setting-up-gaiacli)
+
+现在，你都准备好去[发送交易到网络](./delegator-guide-cli.md#sending-transactions).
+
+
+
diff --git a/docs/translations/cn/gaia/validators/overview.md b/docs/translations/cn/gaia/validators/overview.md
new file mode 100644
index 000000000..31b3f6e56
--- /dev/null
+++ b/docs/translations/cn/gaia/validators/overview.md
@@ -0,0 +1,38 @@
+# 验证人概览
+
+## 介绍
+
+Cosmos Hub基于Tendermint，它依赖于一组负责在区块链中提交新区块的验证人。这些验证人通过广播投票来参与共识协议，投票包含由每个验证人的私钥签名的加密签名。
+
+验证人候选者可以绑定他们自己的Atoms=，还能让token持有者将Atoms=“委托”或“抵押”给他们。Cosmos Hub将有100个验证人，但随着时间的推移，将根据预定义的时间表增加到300个验证人。验证人根据谁拥有最多的投票权来确定——拥有最多股权的前100名验证人候选者将成为Cosmos的验证人。
+
+验证人及其委托人能通过执行Tendermint共识协议赚取Atom作为区块增发奖励和作为交易手续费的其他token。最初，交易费用将以Atom支付，但在将来，Cosmos生态中的任何token如果通过治理加入到白名单中，就能作为有效的交易手续费。请注意，验证人可以设置从他们的委托人身上收取的佣金作为额外奖励。
+
+如果验证人双签，频繁下线或不参与治理，则可以削减其抵押的Atom（包括那些用户委托给他们的Atom）。处罚取决于违规的严重程度。
+
+
+## 硬件
+
+目前还没有合适的针对验证人密钥管理的云解决方案。这可能会等到2018年云解决方案SGX变得更加普及时才会有所改善。由于这个原因，验证人必须设置一个受限访问的物理操作。例如，安置在安全的数据中心。
+
+验证人期望为他们的数据中心装备充足的电力，带宽及存储备份。期望有数个充足的对应光纤，防火墙还有路由的需求的网络设备，一台有着足够硬盘和容错能力的小型服务器。硬件可以先从低端的数据中心配置开始。
+
+我们预计最初的网络需求是比较低的。当前的测试网络只需要极小的资源。之后，带宽，CPU和内存的需求将会随着网络的发展而增长。要存储数年区块链的历史信息的话，推荐配置足够大的的硬盘。
+
+
+## 创建一个网站
+
+建立一个专门的用以显示验证人信息网站，并在我们的[论坛](https://forum.cosmos.network/t/validator-candidates/127/3)上表明您想成为验证人的意图。这非常重要，因为委托人希望获得关于他们予以Atom委托的验证人的信息。
+
+
+## 寻求法律建议
+
+如果您打算成为一个验证人，请寻求法律建议
+
+
+## 社区
+
+在我们的社区聊天频道和论坛上讨论有关成为验证人的更多细节：
+
++ [Validator Chat](https://riot.im/app/#/room/#cosmos_validators:matrix.org)
++ [Validator Forum](https://forum.cosmos.network/c/validating)
\ No newline at end of file
diff --git a/docs/translations/cn/gaia/validators/security.md b/docs/translations/cn/gaia/validators/security.md
new file mode 100644
index 000000000..b2e4a1982
--- /dev/null
+++ b/docs/translations/cn/gaia/validators/security.md
@@ -0,0 +1,55 @@
+# 验证人安全
+
+我们鼓励每一个验证人候选者独立运行其操作，因为不同的设置增加了网络的抵抗能力。为了能按时启动主网，验证人候选者现在就应该开始设置了。
+
+
+## 密钥管理 - HSM
+
+让攻击者无法盗取验证人的密钥是至关重要的任务。如果可能发生盗取，这将会使委托给抵抗力脆弱的验证人的所有股权都处于风险之中。硬件安全模块是防范该风险的一个重要策略。
+
+为了支持Cosmos Hub，HSM模块必须要支持`ed25519`签名。YubiHSM2支持了`ed25519`，我们期望在2017年12月时，能有一个可以使用的库。YubiHSM可以保护私钥但是不能确保它不会去重复签署一个区块。
+
+Tendermint团队也在为拓展Ledger Nano S应用以支持验证人签名做贡献。这个应用将会储存最近的区块，并能降低双重签名攻击的风险。
+
+我们会在有更多关于密钥保存安全的可行的解决方案出现时更新这个文档。
+
+
+## 哨兵节点（DDOS防御）
+
+验证人有责任确保网络能够经受住DDOS攻击。
+
+降低这种风险的一个推荐方案是验证人要在成为哨兵节点的网络拓扑结构上去精心搭建他们的网络结构。
+
+因为验证人节点可以操作自身，也可以被其熟知的其它验证人运行，验证人节点应该只连接到其所信任的全节点上。一个验证人节点通常会运行在一个数据中心。大部分数据中心提供对主流云服务提供商的直接网络连接服务。验证人可以去连接云服务中上的哨兵节点。验证人节点直接连接到其哨兵节点，减缓了DDOS攻击带来的压力，还可以添加多个新的哨兵节点用以轮换来减轻已存在哨兵节点所遭受到的攻击。
+
+哨兵节点能够迅速轮换或者改变它们的IP地址。因为与哨兵节点的连接是在私有的IP网段，基于因特网的攻击不可能直接骚扰到验证人节点。这将确保验证人区块的提交和投票总是能广播至网络中的其余节点。
+
+你可以按照下面的指令去设置你的哨兵节点架构：
+
+验证人节点必须编辑它们的config.toml文件：
+
+```bash
+# Comma separated list of nodes to keep persistent connections to
+# Do not add private peers to this list if you don't want them advertised
+persistent_peers =[list of sentry nodes]
+
+# Set true to enable the peer-exchange reactor
+pex = false
+```
+
+哨兵节点应该编辑它们的config.toml文件:
+
+```bash
+# Comma separated list of peer IDs to keep private (will not be gossiped to other peers)
+private_peer_ids = "ipaddress of validator nodes"
+```
+
+## 环境变量
+
+默认情况下，具有以下前缀的大写环境变量将替换小写命令行标志：
+
++ `GA`（对应Gaia的标识）
++ `TM`（对应Tendermint的标识）
++ `BC`（对应democli或basecli的标识）
+
+例如，环境变量`GA_CHAIN_ID`将映射到命令行标识`--chain-id`。注意，虽然显式命令行标识优先于环境变量，但环境变量优先于任何配置文件。因此，必须锁定环境，以便在CLI上将任何关键参数定义为标识或防止修改任何环境变量。
\ No newline at end of file
diff --git a/docs/translations/cn/gaia/validators/validator-faq.md b/docs/translations/cn/gaia/validators/validator-faq.md
new file mode 100644
index 000000000..52562f30a
--- /dev/null
+++ b/docs/translations/cn/gaia/validators/validator-faq.md
@@ -0,0 +1,328 @@
+# 验证人相关问题
+
+::: 声明
+这项工作正在进行中。机制和具体值都容易发生变化。
+:::
+
+## 基本概念
+
+### 什么是验证人？
+
+[Cosmos Hub](../what-is-gaia.md)基于[Tendermint](https://tendermint.com/docs/introduction/what-is-tendermint.html)，它依靠一组验证人来保障网络的安全。验证人的作用是通过广播包含由验证人的私钥签名的加密签名的投票来运行全节点并参与共识。验证人在区块链中提交新的区块并获得收益作为报酬。他们还必须通过对提案进行投票来参与治理。验证人根据他们的总抵押股权来排位。
+
+
+### 什么是'抵押'?
+
+Cosmos Hub是一个权益证明（PoS）区块链，意味着验证人的权重由其抵押的，用作担保金的代币（Atom）的数量决定。这些Atom可以直接由验证人抵押，或者由Atom持有者委托给验证人。
+
+系统中的任何用户都可以通过发送`create-validator`交易来表明其想成为验证人的意图。从那里，他们成为验证者。从这开始，才能成为验证人。
+
+验证人的权重（即总抵押）决定其是否能成为有效验证人，还有该节点提议区块的频率以及它将获得多少收益。一开始，只有权重最多的100个验证人才是有效验证人。如果验证者双重签名，经常脱机或不参与治理，如果验证人双签，频繁掉线或者不参加治理，他们抵押的Atom(包括那些委托给他们的Atom)会被销毁，也就是‘削减处罚’。
+
+
+### 什么是全节点？
+
+全节点是一个全程验证区块链的交易和区块的程序。区别于只处理区块头信息和小部分交易的轻节点。运行一个全节点比轻节点需要更多的资源，这也是成为验证人必须要具备的。实际上，运行全节点意味着运行网络延迟较低且不掉线的软件的最新版本。
+
+当然，我们鼓励任何用户都去运行一个全节点，即使他们并不打算成为验证人。
+
+
+### 什么是委托人？
+
+委托人是那些没有能力或者不想执行验证人操作的Atom持有者。通过[Cosmos Voyager](https://cosmos.network/docs/getting-started/voyager.html)，一个用户可以把Atom委托给一个验证人，并获取一部分交易收益（关于收益是如何分配的，查看下面的[**抵押有什么激励?**](#抵押有什么激励?)和[**运行一个验证人有什么激励?**](#运行一个验证人有什么激励?)）
+
+委托人与他们的验证人分享收益，所以委托人也要共担责任。如果一个验证人行为不端，每一个相关的委托人也会按比例遭受股权的部分削减处罚。这就是为什么委托人在委托之前应该履行调查职责，还要尽量把股权分散给多个验证人。
+
+委托人在系统里扮演了一个关键角色，因为他们负责选举验证人。委托人也并不是一个消极的角色：委托人应该积极监控验证人的行为，并参与到治理当中。
+
+
+## 成为一个验证人
+
+### 如何成为一个验证人？
+
+网络中的任何参与者都可以通过发送一笔`create-validator`交易来表明他们想成为一个验证人，必须要填写下列参数：
+
++ **验证人的公钥：**用于签名**投票**和**提交**的私钥对应的公钥。通过这种方式，验证人可以用不同的账户分别去做验证和持有流动资金。
++ **验证人的地址：**应用程序级别的地址。这是用于外界识别验证人的地址。与此地址关联的私钥用于绑定，取消绑定，声明奖励和参与治理（仅限MVP）。
++ **验证人的名称(moniker)**
++ **验证人的网站（可选的）**
++ **验证人的描述信息（可选的）**
++ **初始佣金比例：**区块增发奖励，区块奖励，交易手续费中抽成给验证人的初始比例
++ **最大佣金：**该验证人保证的最大佣金率
++ **佣金变化率：**验证人候选者的最大每日佣金增长率
++ **最小自抵押数量：**验证人在任何时候所要的抵押的最小Atom数量。如果验证人的自抵押股权数量跌破了这个限制，其整个抵押池都会被释放。
++ **初始自抵押数量：**验证人最初的自抵押的Atom数量
+
+一旦创建了验证人，Atom持有者可以向其委托Atom，有效地向股权池里增加股权。一个地址的总股权是验证人自抵押的Atom和委托人委托的Atom的总和。
+
+在所有表明的验证人中，股权最多的100名被任命为有效验证人。如果某个验证人的股权总量跌出了前100名就会失去验证人权利。随着时间的推移，验证人的最大数量会依照计划逐渐增加：
++ **Year 0:** 100
++ **Year 1:** 113
++ **Year 2:** 127
++ **Year 3:** 144
++ **Year 4:** 163
++ **Year 5:** 184
++ **Year 6:** 208
++ **Year 7:** 235
++ **Year 8:** 265
++ **Year 9:** 300
++ **Year 10:** 300
+
+
+## 测试网
+
+### 我要怎样加入到测试网？
+测试网络是一个在主网上线之前很好的测试验证人设置的环境。
+
+我们将参与测试网络视为一个向社区展示你是有准备且有能力去运行验证人节点的方式。你可以在[这里](https://github.com/cosmos/cosmos-sdk/tree/develop/cmd/gaia/testnets)和[这里](https://github.com/cosmos/testnets)找到有关测试网的更多内容。
+
+
+### 密钥的不同类型？
+
+简而言之有两种密钥：
+
++ **Tendermint Key** ：这是用于对区块哈希进行签名的唯一密钥。它与一个公钥`cosmosvalconspub`相关联。
+	+ 使用`gaiad init`创建节点时生成。
+	+ 使用`gaiad tendermint show-validator`查看，如`cosmosvalconspub1zcjduc3qcyj09qc03elte23zwshdx92jm6ce88fgc90rtqhjx8v0608qh5ssp0w94c`。
++ **Application keys** ：这些密钥是由应用程序创建的，用于签名交易。作为验证人，你可能会使用一个密钥来签名与抵押相关的交易，另一个密钥用于签署与治理相关的交易。应用程序私钥和公钥`cosmospub`及地址`cosmos`相关联。两者都来自`gaiacli keys add`生成的帐户私钥。
+	+ 注意：验证人的操作员的私钥直接绑定到应用程序私钥，但为此目的保留前缀：`cosmosvaloper`和`cosmosvaloperpub`
+
+
+### 验证人可以具有哪些不同的状态
+
+使用`create-validator`交易创建验证人后，它可以处于三种状态：
+
++ `bonded` : 验证人在活跃集合中并参与共识。验证人正在获得奖励，并且可能因为不当行为而遭到削减处罚。
++ `unbonding` : 验证人不在活跃集合中，也不参与共识。验证人没有获得奖励，但仍然可能因为不当行为而遭到削减处罚。这是从`bonded`到`unbonding`的过渡状态。如果验证人在`unbonding`模式下未发送`rebond`交易，则状态转换将需要三周时间才能完成。
++ `unbonded` : 验证人不在活跃集合中，因此不签署区块。验证人不能遭到削减处罚，也不会获得任何奖励。仍然可以将Atom委托给此验证人。从`unbonded`状态的验证人取消委托是立即的。
+
+委托人与其验证人具有相同的状态。
+
+请注意，委托不一定是绑定的。Atom可以是delegated和bonded状态，delegated和unbonding状态，delegated和unbonded状态，或流通状态。
+
+
+### 什么是`self-bond`?怎样增加我的`self-bond`?有水龙头吗？
+
+如果你想获得测试网的测试币，你可以使用这个[水龙头](https://faucet.cosmos.network/)。
+
+
+### 成为一个活跃的（=bonded）验证人必须要抵押最小数量的Atom吗？
+
+没有最小限制。总股权（总股权=自抵押股权+委托股权）最高的前100名是活跃验证人。
+
+
+#### 委托人要怎样选择验证人?
+
+委托人可以根据他们的主观判断随意去选择验证人。也就是说，包括对以下内容的判断相当重要：
+
++ **自抵押的Atom数量**：一个验证人在股权池里自抵押的Atom数量。有着更多自抵押Atom的验证人承担了更大的风险，将促使其对自己的行为更加负责。
++ **委托的Atom总量**: 委托给某个验证人的Atom总量。大量的股权显示社区对该验证人的信任，但这也意味着该验证人更容易成为黑客们的目标。实际上，黑客更倾向攻击更大的验证人，这样他们可能会从不能抵御攻击的验证人那里获得更多。随着委托的Atom的增长，验证人也被期待不要太过引人注目。
++ **佣金比率**： 在把奖励分散给委托人之前抽成一部分佣金来奖励验证人。
++ **跟踪记录**：委托人很可能去查看他们计划去委托的验证人的行为记录。包括资历，过去对提议的投票，历史的平均运行时长和验证人节点掉线的频率。
+
+除去这些会展示在Cosmos Voyager上的评判标准，验证人还可能向公众展示一个网站来完善他们的简历。验证人需要通过多种方式去树立良好的声誉来吸引委托人。比如，验证人让第三方来审计他们的设置就是一个很好的实践。注意，Tendermint团队将不会批准和引导任何对自身的审计。有关尽职调查的更多信息，请参阅此[博客](https://medium.com/@interchain_io/3d0faf10ce6f)
+
+## 责任
+
+### 验证人需要公开表明身份吗?
+
+不需要。每个委托人会用他们自己的评判标准去衡量验证人的价值。验证人可以（也被推荐）在他们提名自己时注册一个网站，以便他们可以按照自己的意愿宣传自己的行动。一些委托人可能更喜欢通过一个清楚展示团队是如何去运行验证人节点以及团队成员的简历的网站来帮助选择，尽管其他一些委托人更偏好那些隐藏了行为记录的匿名验证人。最有可能的是身份明确的验证人和匿名的验证人都会存在于验证人集合中。
+
+
+### 一个验证人要担负哪些责任？
+
+验证人有两个主要的职责：
+
++ **能够不断运行软件的正确版本**：验证人需要去保证他们的服务器任何时刻都在线，保护其私钥避免遭到窃取。
++ **积极地参与治理**：验证人需要对每个提案投票表决。
+
+此外，验证人应该是社区的活跃成员。他们应该始终与生态系统的当前状态保持同步，以便他们能够轻松适应任何变化。
+
+
+### "参与治理"需要?
+
+Cosmos Hub中的验证人员和委托人可以就改变运行参数（例如区块燃料限制），协调升级以及对治理Cosmos Hub的宪法的修正方案进行投票表决。
+
+验证人在治理系统中发挥着特殊作用。身为系统的支柱他们需要对每一个提案进行投票表决。这是尤其重要的，因为委托人把票权给了验证人而自己无法直接去投票。每次当某个验证人不去对一个提案投票表决时，他就会遭受削减处罚。
+
+### 抵押是指？
+
+抵押Atom可以被认为是一种在验证活动中进行的安全储蓄。当一个验证人或者委托人想要拿回部分甚至所有的存款时，他们就发送一笔unbonding交易。然后，Atom会经历一个*3周的解绑周期*，在unbonding开始前他们容易因错误提交而遭到削减处罚。
+
+验证人，和与其形成联盟的委托人，得到区块增发奖励，区块奖励和手续费奖励，还有参与治理的权利。如果一个验证人行为不端，它的总股份的一部分会遭削减处罚（处罚的严厉性取决于错误行为的类型）。这意味着每一个往验证人委托Atom的用户也会受到一定比例的处罚。因此委托人倾向于把Atom委托给那些规范安全运作的验证人。
+
+
+### 验证人可以卷走委托人的Atom跑路吗?
+
+向一个验证人委托，用户只是委托了他的股权。验证人有更多的股权，在共识和治理工程中也就有了更大的权重。这不意味着验证人可以扣押其委托人的Atom。一个验证人是绝不可能带着委托人的Atom跑路的。
+
+尽管委托资金不可能被验证人盗取，委托人仍然要对他们的验证人做出的不端行为负责。这种情况下，每个委托人的股权也会按其股权比例遭到部分的削减处罚。
+
+
+### 一个验证人多久被选择提议下一个区块？会随着抵押的Atom数量上升吗？
+
+被选作提议下一个区块的验证人称为提案人。每个提案人都是由明确的方式选出来的，被选的频率也与他们的总股权相等（总股权=自抵押股权+委托股权）。比如，如果所有验证人总的抵押股权是100个Atom，一个验证人的总股权是10个Atom，那么有10%的时间该验证人会被选作下一个提案人。
+
+
+### Cosmos Hub的验证人需要去验证Cosmos生态中的其他分区吗？
+
+是的，他们会如此。最初，Cosmos Hub的验证人还会验证第一个公共Ethermint分区。如果通过治理决定这么做，Cosmos Hub的验证人可能需要去验证Cosmos生态系统里的其它分区。就Ethermint分区而言，对每个额外的分区奖励都会以区块奖励和交易手续费的形式来提供。
+
+
+## 激励
+
+### 抵押有什么激励？
+
+一个验证人股权池里的每个成员赚取不同类型的收益：
+
++ **区块增发奖励**： 验证人运行的应用里的原生的token（例如Cosmos Hub中的Atom）会是通胀的，用作区块增发奖励。这些增发奖励激励Atom持有者去抵押他们的股权，所以未绑定的Atom会随着时间的流逝而稀释。
++ **区块奖励**： 对于Ethermint分区，区块奖励会以Photon来支付。对Ethereum进行硬分叉来完成初始的分配。这意味着Photon会按和Ether的比例1：1发放。
++ **交易手续费**：Cosmos Hub维持一个token的白名单，上面的token都能作为手续费。
+
+这些总收益会按验证人股权池中每个验证人所占的权重来进行分配。然后，每个验证人的股权池的收益又会根据其每一个委托人的股权来分配。注意，会在分配前从委托人所得中抽取佣金给予验证人。
+
+
+### 运行一个验证人有什么激励?
+
+由于能抽成佣金，验证人比起他们的委托人能按比例赚取更多的收益。
+
+验证人在治理中充当一个重要角色。如果一个委托人没有投票，他也能从他的验证人那里继承到投票权。这样验证人在生态里承担主要的责任。
+
+
+### 什么是验证人的佣金?
+
+一个验证人的股权池收到的收益会被拆分为给验证人的部分和给委托人的部分。验证人可以从给其委托人的收益中抽取一部分作为给自己佣金奖励。这个佣金被设置成一个百分比。每个验证人可以随意设置初始佣金，最大每日佣金变化率和最大佣金。Cosmos Hub强制每个验证人都要明确设置这些参数。这些参数只能在一开始声明竞选时设置，也只可能在声明之后被进一步限制。
+
+
+### 区块增发奖励怎么分配?
+
+区块增发奖励会按验证人的总股权来成比例地发放。这意味着即使每个验证人每次增发奖励时都获得了Atom，但所有验证人仍然会维持相等的权重。
+
+让我们举一个例子：我们有着股权相等的10个验证人，佣金比例是1%。然后我们假设一个区块的增发奖励是1000个Atom，每一个验证人有20%的自抵押Atom。这些token不会直接分给提案人。而是被均匀地分发给验证人。所以现在每个验证人的股权池获得100个Atom。这100个Atom会依据每个参与者的股权来分发：
+
++ 佣金：` 100*80%*1% = 0.8 Atoms `
++ 验证人获得部分： ` 100*20% + 佣金 = 20.8 Atoms `
++ 委托人获得部分： ` 100*80% - 佣金 = 79.2 Atoms `
+
+然后，每个委托人可以按照他们在验证人股权池中的股权，从79.2个Atom中等比例地索要属于他们应得的那一份。注意验证人的佣金不仅只适用于区块增发奖励，也适用于区块奖励（使用Photon支付）。
+
+
+### 交易手续费怎么分配?
+
+手续费以类似的方式分发，不同之处在于，如果区块的提案人有多于明确的提交所需的最小值，区块提案人就可以在由其提议的区块手续费中获得一笔奖励。
+
+当一个验证人被选作去提议下一个区块时，必须要含有对当前区块至少2/3的验证人签名许可。尽管如此，仍然存在有一个激励去奖励那些超过2/3的验证人签名许可。这个奖励是线性的：如果提案人含有2/3的签名许可（区块有效的最小值），比例是1%， 如果提案人含有100%的签名许可，比例是5%。当然，提案人不应该等待太久去做提案，或许其他的验证人有可能超时，长时间的等待容易造成提案的延误。这样的话，验证人不得不在获取最多签名的等待时间和失去对下个区块的提案之间寻找一个平衡点。这个机制旨在提案人不要去提案空块，维护验证人之间更好的网络，还有减轻审查。
+
+让我们举一个实际的例子来说明上面的概念。在这个例子中，有着10个股权相等的验证人。每个验证人采用1%的佣金比例，有20%的自抵押Atom。现在，产出了一个有着1025.51020408个Atom手续费的区块。
+
+首先，一个 2% 的税是必须的。这部分Atom会进入贮存池中。贮存池里的资金会通过治理来分配，用来作奖赏和更新升级的花费。
+
++ ` 2% * 1025.51020408 = 20.51020408 Atoms ` 进入到贮存池中
+
+现在只剩下了1005个Atom。让我们假设提案人提案的区块包含了100%的验证人签名。因此提案人能获得手续费奖励中的5%的额外奖励。
+
+我们解这个简单的算式得出给每一个验证人的奖励R :
+
+` 9*R + R + R*5% = 1005 ⇔ R = 1005/10.05 = 100 `
++ 对于发起提案的验证人：
+	+ 奖金池获得 ` R + R * 5% = 105 Atoms `
+	+ 佣金： ` 105 * 80% * 1% = 0.84 Atoms `
+	+ 验证人的奖励： ` 105 * 20% + 佣金 = 21.84 Atoms `
+	+ 委托人的奖励： ` 105 * 80% - 佣金 = 83.16 Atoms `（每个委托人可以按照他们的股权占比等比例地索要这部分奖励）
++ 对于每个非提案验证人：
+	+ 奖金池获得 ` R = 100 Atoms `
+	+ 佣金： ` 100 * 80% * 1% = 0.8 Atoms `
+	+ 验证人的奖励： ` 100 * 20% + 佣金 = 20.8 Atoms `
+	+ 委托人的奖励： ` 100 * 80% - 佣金 = 79.2 Atoms `（每个委托人可以按照他们的股权占比等比例地索要这部分奖励）
+
+
+### 遭到削减处罚的原因?
+
+如果一个验证人行为不端，其抵押的股权，连同其委托人的股权都会遭到削减处罚。处罚的严重性依据错误的类型来定。有3个主要的错误会导致验证人和其委托人的资金遭到削减处罚：
++ **双签**：如果某人反馈在A链上，一个验证人在相同高度的A链和B链上签署了两个区块，这个验证人会被A链处罚。
++ **不在线**： 如果一个验证人的签名没有被最近的X个区块包含，对该验证人会按与X成比例的最低额度来处罚。如果X高于某个限制Y，这个验证人会被赎回下线。
++ **不投票**： 如果一个验证人没有对某个提案投票表决，一旦被某个人举报，他的股权会受到削减处罚。
+
+请注意，即使一个验证人并不是有意作恶，在出现节点崩溃，失去连接，被DDOS攻击，或者是私钥泄露的情况时，仍然会被遭受削减处罚。
+
+
+### 验证人需要去自抵押一些Atom吗?
+
+不，他们不必。一个验证人的总股权等于其自抵押股权和受委托股权的总和。这意味着一个验证人可以通过吸引更多委托人来补偿其低额的自抵押股权。这也是为何对验证人而言，良好的声誉是极其重要的。
+
+尽管对验证人来说是并没有义务去自抵押Atom，委托人还是希望他们的验证人在其股权池里有一定的自抵押Atom。换句话说，验证人应该共担风险。
+
+为了委托人能获得一些与之共担风险的验证人给予的保证，验证人可以声明一个最小数量的自抵押Atom额度。如果一个验证人的自抵押额度低于预先定义的限制，该验证人和其所有的委托人的股权都会被赎回。
+
+
+### 怎样预防股权集中到少数的验证人手中？
+
+目前我们期望社区能有更明智的和有自我保护意识的行为表现。当一个Bitcoin的矿池获得过多的算力时，社区通常会停止向该矿池贡献算力。Cosmos Hub在初期也将会依赖同样的方式。之后，其他的机制会被应用，来尽可能地使这个过程更顺畅：
+
++ **免处罚的重新委托** ：这允许委托人轻易地从一个验证人切换到另一个验证人，从而降低对验证人的粘性
++ **黑客赏金**： 激励社区去攻击验证人。攻击者将获得与所攻击的验证人规模成比例的赏金，促使一个验证人随着其总股权的增长，成为一个受人关注的攻击目标。
++ **UI警告**： 如果用户想要去委托股权给一个已经有了大量股权的验证人的话，用户会收到来自Cosmos Voyager的警告。
+
+
+
+## 技术要求
+
+### 对硬件的要求是什么？
+
+我们期望验证人供应一个或多个的有着充足电力，网络资源，防火墙安全，HSM和服务器的数据中心。
+
+我们期望初期能有一个适度级别的硬件规格说明书，会随着网络使用的增长而逐步提高标准。参与到测试网络是了解更多情况的不错方式。
+
+
+### 对软件有什么要求？
+
+除了能运行一个Cosmos Hub节点，验证人还应该开发相关的监控，预警和管理工具。
+
+
+### 对带宽有什么要求？
+
+与像Ethereum或Bitcoin这样的区块链相比，Cosmos网络要有高吞吐量的性能。
+
+我们建议数据中心只在云服务上连接信任的全节点或者是熟知的验证人节点，这会减轻数据中心遭受DDOS攻击的压力。
+
+最后，随着网络越来越被重度使用，具有单日GB级别的带宽是可能的。
+
+### 运行一个验证人节点意味着什么？
+运行一个成功的验证人节点需要多方面的高超技艺的和持久关注的共同努力。相比运行一个Bitcoin矿工节点要付出更多。
+
+### 怎样去进行密钥管理?
+
+我们期望验证人去运行一个HSM来支持ed25519密钥。下面是可能的选择：
+
++ YubiHSM 2
++ Ledger Nano S
++ Ledger BOLOS SGX enclave
++ Thales nShield support
+
+Tendermint团队不会推荐上面的其中之一。鼓励社区最好加强改进HSM和密钥管理的安全性。
+
+### 在操作上我们期望验证人可以做到哪些?
+
+进行有效率的操作是避免验证人节点的意外掉线或遭到削减处罚的关键所在。这包括良好的攻击应对方法，断电情况，还有维持数据中心的安全性和独立性。
+
+
+### 维护需要什么？
+
+验证人应该去执行常规的软件升级以适应更新和修复漏洞。在启动阶段的前期阶段不可避免的会出现一些网络问题，这需要大量的警觉。
+
+
+### 验证人怎样保护自己免于DDOS攻击？
+
+当一个攻击者向一个IP地址发送海量的因特网流量来阻止该IP地址上的网络服务时，这就是DDOS攻击。
+
+一个攻击者扫描网络，尽量去获得多个验证人节点的IP地址，然后通过向他们发送海量流量来阻断他们之间的连接。
+
+一个降低这样的风险的推荐做法是验证人在所谓的哨兵节点的架构中精心去构建他们的网络拓扑结构。
+
+验证人节点应该只连接到他们所信任的全节点上，因为他们可以操作自身，也可以被他们熟知的其他验证人运行。一个验证人节点通常会运行在一个数据中心。大部分数据中心提供对主流云服务提供商的直接网络连接服务。验证人可以使用去连接云服务中的哨兵节点。验证人节点直接连接到他们的哨兵节点，这样减缓了DOS攻击带来的压力，可能需要新的哨兵节点被激活去减轻已存在的哨兵节点所遭受到的攻击。
+
+哨兵节点能够迅速地被轮换或者改变它们的IP地址。因为与哨兵节点的连接是私有的IP网段，基于因特网的攻击不可能直接骚扰到它们。这将确保验证人区块的提交和投票总是能传播到网络中的其余节点。
+
+期待验证人在这方面良好的操作将完全消除这些威胁。
+
+了解哨兵节点架构的更多信息请看[这里](https://forum.cosmos.network/t/sentry-node-architecture-overview/454)。
\ No newline at end of file
diff --git a/docs/translations/cn/gaia/validators/validator-setup.md b/docs/translations/cn/gaia/validators/validator-setup.md
new file mode 100644
index 000000000..ca87ebd44
--- /dev/null
+++ b/docs/translations/cn/gaia/validators/validator-setup.md
@@ -0,0 +1,216 @@
+# 在主网上运行一个验证人
+
+::: 提示
+加入主网所需的信息(`genesis.json`和种子节点)在[`lauch` repo](https://github.com/cosmos/launch/tree/master/latest)中可以找到。
+:::
+
+在启动你验证人节点前，确定你已经完成了[启动全节点](../join-mainnet.md)教程。
+
+## 什么是验证人?
+
+[验证人](./overview.md)负责通过投票来向区块链提交新区块。如果验证人不可访问或者对多个相同高度的区块签名，将会遭受到削减处罚。如果变得不可用或者在同一高度上签名，则会被削减。请阅读有关Sentry节点架构的信息，以保护您的节点免受DDOS攻击并确保高可用性。请阅读[哨兵节点网络架构]()来保护你的节点免于DDOS攻击并保证高的可访问性。
+
+::: 警告
+如果你想要成为Cosmos Hub主网的验证人，你应该[安全研究](./security.md)。
+:::
+
+如果你已经[启动了一个全节点](../join-mainnet.md)，可以跳过下一节的内容。
+
+## 创建你的验证人
+
+你的`cosmosvalconspub`可以用于通过抵押token来创建一个新的验证人。你可以通过运行下面的命令来查看你的验证人公钥：
+
+```bash
+gaiad tendermint show-validator
+```
+
+使用下面的命令创建你的验证人：
+
+::: 注意
+不要使用多于你所拥有的`uatom`!
+:::
+
+```bash
+gaiacli tx staking create-validator \
+  --amount=1000000uatom \
+  --pubkey=$(gaiad tendermint show-validator) \
+  --moniker="choose a moniker" \
+  --chain-id=<chain_id> \
+  --commission-rate="0.10" \
+  --commission-max-rate="0.20" \
+  --commission-max-change-rate="0.01" \
+  --min-self-delegation="1" \
+  --gas="auto" \
+  --gas-prices="0.025uatom" \
+  --from=<key_name>
+```
+
+::: 提示
+在指定commission参数时，`commission-max-change-rate`用于度量`commission-rate`的百分比点数的变化。比如，1%到2%增长了100%，但反映到`commission-rate`上只有1个百分点。
+:::
+
+::: 提示
+如果没有指定，`consensus_pubkey`将默认为`gaiad tendermint show-validator`命令的输出。`key_name`是将用于对交易进行签名的私钥的名称。
+:::
+
+你可以在第三方区块链浏览器上确定你是否处于验证人行列。
+
+## 以初始验证人的形式加入到genesis文件
+
+::: 警告
+这一节内容只针对想要在Cosmos Hub主网启动前就作为初始验证人身份的节点。如果主网已经启动，请跳过这一节。
+:::
+
+如果你想作为初始验证人被写入到genesis.json文件，你需要证明你在创世状态中有一些权益代币，创建一个（或多个）交易以将股权与你的验证人地址联系起来，并将此交易包含在genesis文件中。
+
+你的`cosmosvalconspub`可以用于通过抵押token来创建一个新的验证人。运行如下命令来获取你的验证人节点公钥：
+
+```bash
+gaiad tendermint show-validator
+```
+
+然后执行`gaiad gentx`命令:
+
+::: 提示
+`gentx`是持有self-delegation的JSON文件。所有的创世交易会被`创世协调员`收集起来验证并初始化成一个`genesis.json`
+:::
+
+::: 注意
+不要使用多于你所拥有的`uatom`!
+:::
+
+```bash
+gaiad gentx \
+  --amount <amount_of_delegation_uatom> \
+  --commission-rate <commission_rate> \
+  --commission-max-rate <commission_max_rate> \
+  --commission-max-change-rate <commission_max_change_rate> \
+  --pubkey <consensus_pubkey> \
+  --name <key_name>
+```
+
+::: 提示
+在指定佣金相关的参数时，`commission-max-change-rate`用于标识`commission-rate`每日变动的最大百分点数。比如从1%到2%按比率是增长了100%，但只增加了1个百分点。
+:::
+
+你可以提交你的`gentx`到[launch repository](https://github.com/cosmos/launch). 这些`gentx`将会组成最终的genesis.json.
+
+## 编辑验证人的描述信息
+
+你可以编辑验证人的公开说明。此信息用于标识你的验证人节点，委托人将根据此信息来决定要委托的验证人节点。确保为下面的每个标识提供输入，否则该字段将默认为空（ `--moniker`默认为机器名称）。
+
+<key_name>指定你要编辑的验证人。如果你选择不包含此标识，记住必须要含有--from标识来指定你要更新的验证人。
+
+`--identity`可用于验证和Keybase或UPort这样的系统一起验证身份。与Keybase一起使用时，`--identity`应使用由一个[keybase.io](https://keybase.io/)帐户生成的16位字符串。它是一种加密安全的方法，可以跨多个在线网络验证您的身份。 Keybase API允许我们检索你的Keybase头像。这是你可以在验证人配置文件中添加徽标的方法。
+
+```bash
+gaiacli tx staking edit-validator
+  --moniker="choose a moniker" \
+  --website="https://cosmos.network" \
+  --identity=6A0D65E29A4CBC8E \
+  --details="To infinity and beyond!" \
+  --chain-id=<chain_id> \
+  --gas="auto" \
+  --gas-prices="0.025uatom" \
+  --from=<key_name> \
+  --commission-rate="0.10"
+```
+
+**注意** : `commission-rate`的值必须符合如下的不变量检查：
+
++ 必须在 0 和 验证人的`commission-max-rate` 之间
++ 不得超过 验证人的`commission-max-change-rate`, 该参数标识**每日**最大的百分点变化数。也就是，一个验证人在`commission-max-change-rate`的界限内每日一次可调整的最大佣金变化。
+
+
+## 查看验证人的描述信息
+
+通过该命令查看验证人的描述信息:
+
+```bash
+gaiacli query staking validator <account_cosmos>
+```
+
+## 跟踪验证人的签名信息
+
+你可以通过`signing-info`命令跟踪过往的验证人签名：
+
+```bash
+gaiacli query slashing signing-info <validator-pubkey>\
+  --chain-id=<chain_id>
+```
+
+## unjail验证人
+
+当验证人因停机而"jailed"(入狱)时，你必须用节点操作人帐户提交一笔`Unjail`交易，使其再次能够获得区块提交的奖励（奖励多少取决于分区的fee分配）。
+
+```bash
+gaiacli tx slashing unjail \
+	--from=<key_name> \
+	--chain-id=<chain_id>
+```
+
+## 确认你的验证人节点正在运行
+
+如果下面的命令返回有内容就证明你的验证人正处于活跃状态:
+
+```bash
+gaiacli query tendermint-validator-set | grep "$(gaiad tendermint show-validator)"
+```
+
+你必须要在[区块浏览器](https://explorecosmos.network/validators)中看见你的验证人节点信息。你可以在`~/.gaiad/config/priv_validator.json`文件中找到`bech32`编码格式的`address`。
+
+::: 注意
+为了能进入验证人集合，你的权重必须超过第100名的验证人。
+:::
+
+## 常见问题
+
+### 问题 #1 : 我的验证人的`voting_power: 0`
+
+你的验证人已经是jailed状态。如果验证人在最近`10000`个区块中有超过`500`个区块没有进行投票，或者被发现双签，就会被jail掉。
+
+如果被因为掉线而遭到jail，你可以重获你的投票股权以重回验证人队伍。首先，如果`gaiad`没有运行，请再次启动：
+
+```
+gaiad start
+```
+
+等待你的全节点追赶上最新的区块。接下来，运行以下命令。请注意，`<cosmos>`是你的验证人帐户的地址，`<name>`是验人帐户的名称。你可以通过运行`gaiacli keys list`找到此信息。
+
+```bash
+gaiad start
+```
+
+等待你的全节点追赶上最新的区块高度。然后，运行如下命令。接着，你可以[unjail你的验证人]()。
+
+最后，检查你的验证人看看投票股权是否恢复：
+
+```bash
+gaiacli status
+```
+
+你可能会注意到你的投票权比之前要少。这是由于你的下线受到的削减处罚！
+
+
+### 问题 #2 : 我的`gaiad`由于`too many open files`而崩溃
+
+Linux可以打开的默认文件数（每个进程）是1024。已知`gaiad`可以打开超过1024个文件。这会导致进程崩溃。快速修复运行`ulimit -n 4096`（增加允许的打开文件数）来快速修复，然后使用`gaiad start`重新启动进程。如果你使用`systemd`或其他进程管理器来启动`gaiad`，则可能需要在该级别进行一些配置。解决此问题的示例`systemd`文件如下：
+
+```toml
+# /etc/systemd/system/gaiad.service
+[Unit]
+Description=Cosmos Gaia Node
+After=network.target
+
+[Service]
+Type=simple
+User=ubuntu
+WorkingDirectory=/home/ubuntu
+ExecStart=/home/ubuntu/go/bin/gaiad start
+Restart=on-failure
+RestartSec=3
+LimitNOFILE=4096
+
+[Install]
+WantedBy=multi-user.target
+```
diff --git a/docs/translations/cn/gaia/what-is-gaia.md b/docs/translations/cn/gaia/what-is-gaia.md
new file mode 100644
index 000000000..abcc1d522
--- /dev/null
+++ b/docs/translations/cn/gaia/what-is-gaia.md
@@ -0,0 +1,22 @@
+# Gaia是什么
+
+`gaia`是作为Cosmos SDK应用程序的Cosmos Hub的名称。它有两个主要的入口：
+
++ `gaiad` : Gaia的服务进程，运行着`gaia`程序的全节点。
++ `gaiacli` : Gaia的命令行界面，用于同一个Gaia的全节点交互。
+
+`gaia`基于Cosmos SDK构建，使用了如下模块:
+
++ `x/auth` : 账户和签名
++ `x/bank` : token转账
++ `x/staking` : 抵押逻辑
++ `x/mint` : 增发通胀逻辑
++ `x/distribution` : 费用分配逻辑
++ `x/slashing` : 处罚逻辑
++ `x/gov` : 治理逻辑
++ `x/ibc` : 跨链交易
++ `x/params` : 处理应用级别的参数
+
+> 关于Cosmos Hub : Cosmos Hub是第一个在Cosmos Network中上线的枢纽。枢纽的作用是用以跨链转账。如果区块链通过IBC协议连接到枢纽，它会自动获得对其它连接至枢纽的区块链的访问能力。Cosmos Hub是一个公开的PoS区块链。它的权益代币称为Atom。
+
+接着，学习如何[安装Gaia](./installation.md)
\ No newline at end of file
diff --git a/docs/translations/cn/intro/README.md b/docs/translations/cn/intro/README.md
new file mode 100644
index 000000000..2f7fd13fe
--- /dev/null
+++ b/docs/translations/cn/intro/README.md
@@ -0,0 +1,11 @@
+## SDK介绍
+
+[Cosmos-SDK](https://github.com/cosmos/cosmos-sdk) 是一个架构，用于构建多资产股权证明(PoS)的区块链，比如Cosmos Hub，以及权益证明(PoA)的区块链。
+
+Cosmos SDK的目标是允许开发者从头开始轻松创建原生就能同其他区块链相互操作的自定义区块链。我们设想SDK是类似于npm这样的框架，以在[Tendermint](https://github.com/tendermint/tendermint)之上构建安全的区块链应用程序。
+
+它基于两个主要原则：
++ **可组合性** ：任何人都可以为Cosmos-SDK创建模块，并且集成已经构建的模块就像将它们导入你的区块链应用程序那样简单。
++ **能力** ：SDK受基于功能的安全性的启发，及多年来解决区块链状态机的经验。大多数开发人员在构建自己的模块时需要访问其他第三方模块。鉴于Cosmos-SDK是一个开放框架，一些模块可能是恶意的，这意味着需要安全原则来推理模块间的交互。这些原则基于对象能力。实际上，这意味着不是让每个模块保留其他模块的访问控制列表，而是每个模块都实现称为keeper的特殊对象，这些对象可以传递给其他模块以授予预先定义的一组功能。例如，如果模块A的keeper的实例被传递给模块B，则后者将能够调用一些受限制的模块A的函数。每个keeper的功能由模块的开发人员定义，开发人员需要根据传递到每个第三方模块的功能来理解和审计第三方模块外部代码的安全性。要深入了解请跳转到[本节](./ocap.md)。
+
+### 接着，学习[SDK应用程序架构](./sdk-app-architecture.md)
\ No newline at end of file
diff --git a/docs/translations/cn/intro/ocap.md b/docs/translations/cn/intro/ocap.md
new file mode 100644
index 000000000..70620c0fd
--- /dev/null
+++ b/docs/translations/cn/intro/ocap.md
@@ -0,0 +1,60 @@
+# Object-Capability Model
+
+## 介绍
+在考虑安全性时，最好从特定的威胁模型开始。我们的威胁模型如下:
+
+> 我们假设蓬勃发展的Cosmos-SDK模块生态中会包含错误或恶意的模块。
+
+Cosmos SDK旨在通过以对象能力系统作为基础来解决此威胁。
+
+> 对象能力系统的结构特性有利于代码设计中的模块化，并确保代码实现中的可靠封装。
+>
+> 这些结构上的特性便于分析一个对象能力程序或操作系统的某些安全属性。其中一些 - 特别是信息流属性 - 可以在对象引用和连接级别进行分析，而不依赖于对决定对象行为的代码的任何了解或分析。
+>
+> 因此，可以在存在包含未知或恶意代码的新对象的情况下建立和维护这些安全属性。
+>
+> 这些结构属性源于管理对现有对象的访问的两个规则：
+> 1. 只要对象A持有对象B的引用，A可以向B发送一条消息，。
+> 2. 只要对象A收到了一条包含对象C引用的消息，A可以获得C的引用。根据这两条规则，一个对象只有通过一条先前存在的引用链获得另一个对象的引用，简而言之，“只有连接才能产生连接”。
+
+查看关于[object-capabilities](http://habitatchronicles.com/2017/05/what-are-capabilities/)的文章了解更多。
+
+严格来说，Golang由于几个问题没有完全实现object-capabilities：
++ 普遍有引入原始模块（比如unsafe, os）
++ 普遍重写模块的变量
++ 存在2个以上goroutine时的数据竞态漏洞可以创建非法的接口值
+
+第一点很容易通过审计import和使用适当的依赖版本控制系统（如Dep）来捕获。但第二点和第三点就不容易了，需要成本进行代码审核。
+
+
+## 实践中的对象能力模式
+想法就是只暴露完成工作所需要的部分。
+
+比如，下面的代码片段违反了对象能力原则：
+
+```go
+type AppAccount struct {...}
+var account := &AppAccount{
+    Address: pub.Address(),
+    Coins: sdk.Coins{sdk.NewInt64Coin("ATM", 100)},
+}
+var sumValue := externalModule.ComputeSumValue(account)
+```
+
+方法名`ComputeSumValue`暗示了这是一个不修改状态的纯函数，但传入指针值意味着函数可以修改其值。更好的函数定义是使用一个拷贝来替代：
+
+```go
+var sumValue := externalModule.ComputeSumValue(*account)
+```
+
+在Cosmos SDK中，你可以看到[gaia app](https://github.com/cosmos/cosmos-sdk/blob/develop/cmd/gaia/app/app.go)中对该原则的实践。
+
+```go
+// register message routes
+app.Router().
+  AddRoute(bank.RouterKey, bank.NewHandler(app.bankKeeper)).
+  AddRoute(staking.RouterKey, staking.NewHandler(app.stakingKeeper)).
+  AddRoute(distr.RouterKey, distr.NewHandler(app.distrKeeper)).
+  AddRoute(slashing.RouterKey, slashing.NewHandler(app.slashingKeeper)).
+  AddRoute(gov.RouterKey, gov.NewHandler(app.govKeeper))
+```
diff --git a/docs/translations/cn/intro/sdk-app-architecture.md b/docs/translations/cn/intro/sdk-app-architecture.md
new file mode 100644
index 000000000..cde45b7b6
--- /dev/null
+++ b/docs/translations/cn/intro/sdk-app-architecture.md
@@ -0,0 +1,94 @@
+# SDK应用程序架构
+
+## 状态机
+
+区块链应用的核心是[具有最终确定性的复制状态机](https://en.wikipedia.org/wiki/State_machine_replication)。
+
+状态机是计算机科学概念，一台机器可以具有多个状态，但在任何给定时间只有一个状态，其描述了系统的当前状态，及触发这些状态转变的事务。
+
+给定一个状态S和交易T，状态机会返回一个新的状态S'。
+
+```
++--------+                 +--------+
+|        |                 |        |
+|   S    +---------------->+   S'   |
+|        |    apply(T)     |        |
++--------+                 +--------+
+```
+
+实际上，交易以区块的形式打包在一起以提高过程的效率。给定状态S和包含交易的区块B，状态机将返回新状态S'。
+
+```
++--------+                              +--------+
+|        |                              |        |
+|   S    +----------------------------> |   S'   |
+|        |   For each T in B: apply(T)  |        |
++--------+                              +--------+
+```
+
+在区块链上下文环境中，状态机是确定性的。这意味着如果你从一个给定的状态开始，重放相同顺序的交易，将始终以相同的最终状态结束。
+
+Cosmos SDK为你提供了最大的灵活性用以定义应用程序的状态，交易类型和状态转变函数。使用SDK构建状态机的过程将在接下来的章节中进行更深入细致的描述。但首先，让我们看看状态机是如何使用**Tendermint**进行复制的。
+
+### Tendermint
+
+作为一个开发者，你只需要使用Cosmos-SDK定义状态机，[Tendermint](https://tendermint.com/docs/introduction/introduction.html)将会为你处理网络层上的复制。
+
+```
+                ^  +-------------------------------+  ^
+                |  |                               |  |   Built with Cosmos SDK
+                |  |  State-machine = Application  |  |
+                |  |                               |  v
+                |  +-------------------------------+
+                |  |                               |  ^
+Blockchain node |  |           Consensus           |  |
+                |  |                               |  |
+                |  +-------------------------------+  |   Tendermint Core
+                |  |                               |  |
+                |  |           Networking          |  |
+                |  |                               |  |
+                v  +-------------------------------+  v
+```
+
+Tendermint是一个与应用程序无关的引擎，负责处理区块链的网络层和共识层。实际上，这意味着Tendermint负责传播和排序交易字节。Tendermint Core依赖于拜占庭容错（BFT）算法来达成交易顺序的共识。
+
+Tendermint一致性算法同一组称为**验证人**的特殊节点一起运作。验证人负责向区块链添加交易区块。对于任何给定的区块，有一组验证人V。通过算法选择V中的验证人A作为下一个区块的提议人。如果超过三分之二的V签署了[prevote](https://tendermint.com/docs/spec/consensus/consensus.html#state-machine-spec)和[precommit](https://tendermint.com/docs/spec/consensus/consensus.html#state-machine-spec)，并且区块包含的所有交易都是有效的，则该区块被认为是有效的。验证人集合可以通过状态机中编写的规则进行更改。要深入了解算法，[点击](https://tendermint.com/docs/introduction/what-is-tendermint.html#consensus-overview)。
+
+Cosmos SDK应用程序的主要部分是一个区块链服务程序，它由网络中的每个节点在其本地运行。如果验证人集合中三分之一以下的是拜占庭（即恶意的），则每个节点在同时查询状态时应获得相同的结果。
+
+
+## ABCI
+
+Tendermint通过名为[ABCI](https://github.com/tendermint/tendermint/tree/master/abci)的接口将交易从网络层传递给应用程序，这是应用程序必须要实现的。
+
+```
++---------------------+
+|                     |
+|     Application     |
+|                     |
++--------+---+--------+
+         ^   |
+         |   | ABCI
+         |   v
++--------+---+--------+
+|                     |
+|                     |
+|     Tendermint      |
+|                     |
+|                     |
++---------------------+
+```
+
+注意，Tendermint仅处理交易字节。它不知道这些字节究竟是什么意思。Tendermint所做的只是对交易确定性地排序。赋予这些字节意义是应用程序的工作。Tendermint通过ABCI将交易字节传递给应用程序，并期望返回代码以知晓消息是否成功。
+
+以下是ABCI中最重要的消息类型：
++ `CheckTx` : 当Tendermint Core收到交易时，会将其传递给应用程序以检查其有效性。一个名为“Ante Handler（预处理）”的特殊handler用于执行一系列验证步骤，例如检查手续费用是否足够和验证签名是否合法。如果交易有效，则将交易添加到[mempool（交易池）](https://tendermint.com/docs/spec/reactors/mempool/functionality.html#mempool-functionality)中并广播到对等节点。注意，`CheckTx`不会处理交易（即不会对状态进行修改），因为它们尚未包含在区块中。
++ `DeliverTx` : 当Tendermint Core接收到[有效区块](https://tendermint.com/docs/spec/blockchain/blockchain.html#validation)时，其中的每条交易都将通过`DeliverTx`传递给应用程序进行处理。正是在这一阶段发生了状态转换。“Ante Handler”将再次执行，连同对交易中每条message进行实际处理的handler一起执行。
++ `BeginBlock`/`EndBlock` : 无论区块是否包含交易，这两个消息都将在每个区块的开头和结尾执行。触发自动的逻辑执行是很有用的。过程中要足够小心，因为计算成本高昂的循环运算可能会减慢区块链的速度，甚至在无限循环时区块链本身停滞。
+
+
+有关ABCI方法和类型的详细介绍请[点击](https://tendermint.com/docs/spec/abci/abci.html#overview)。
+
+在Tendermint上构建的任何应用程序都需要实现ABCI接口，来同底层的本地Tendermint引擎进行通信。幸运的是，你不必实现ABCI接口。Cosmos SDK以[baseapp]()的形式提供了样板实现。
+
+### 接下来，学习[SDK的高级设计原则](./sdk-design.md)
\ No newline at end of file
diff --git a/docs/translations/cn/intro/sdk-design.md b/docs/translations/cn/intro/sdk-design.md
new file mode 100644
index 000000000..537a75b91
--- /dev/null
+++ b/docs/translations/cn/intro/sdk-design.md
@@ -0,0 +1,85 @@
+# Cosmos SDK设计概览
+
+Cosmos SDK是一个方便开发者开发基于Tendermint的安全可靠状态机的一套框架。其核心是Golang版的ABCI的实现。它附带一个`multistore`来持久化存储数据还有一个`router`来处理事务。
+
+下面是一个简单的视图，展示了当从Tendermint的`DeliverTx`请求（`CheckTx`的处理流程与其相同，除了不会执行状态的改变）中接收到一笔交易时，基于Cosmos SDK构建的应用程序是如何处理交易的：
+
+1. 解码从Tendermint共识引擎接收到的交易（记住Tendermint只处理`[]bytes`）
+2. 从交易中提取消息并进行基本的合理性检查。
+3. 将每条消息路由至对应的模块进行处理。
+4. 提交状态变更。
+
+该应用程序能让你生成交易，编码它们并传递给地城的Tendermint来进行广播
+
+## `baseapp`
+
+`baseApp`是Cosmos SDK的ABCI的实现样板。它有一个`router`用作把交易路由到对应的模块。你的应用程序的的主体`app.go`文件将定义你自定义的`app`类型，将嵌入`baseapp`。这样，你自定义的`app`类型将自动继承`baseapp`的所有方法。阅览[SDK应用程序教程](https://github.com/cosmos/sdk-application-tutorial/blob/master/app.go#L27)。
+
+`baseapp`的目的是在存储和可扩展状态机之间提供安全接口，同时尽可能少地定义该状态机（保持对ABCI的真实性）。
+
+有关`baseapp`的更多信息，请点击[这里](../concepts/baseapp.md)。
+
+## Multistore
+
+Cosmos SDK为将状态持久化提供了multistore。multistore允许开发者声明任意数量的[`KVStores`](https://github.com/blocklayerhq/chainkit)。`KVStores`只接受`[]byte`类型作为值，因此任何自定义的类型都需要在存储之前使用[go-amino](https://github.com/tendermint/go-amino)进行编码。
+
+multistore用于区分不同的模块的状态，每个都有其模块管理。要了解更多关于multistore的信息，点击[这里](../concepts/store.md)
+
+## Modules
+
+Cosmos SDK的强大之处在于其模块发开发的理念。SDK应用程序通过把一组可以互相操作的模块组合起来生成。每个模块定义状态的自己并包含其自己的消息/交易处理器，而SDK负责将每条消息路由到其各自归属的模块。
+
+```
+                                      +
+                                      |
+                                      |  Transaction relayed from Tendermint
+                                      |  via DeliverTx
+                                      |
+                                      |
+                +---------------------v--------------------------+
+                |                 APPLICATION                    |
+                |                                                |
+                |     Using baseapp's methods: Decode the Tx,    |
+                |     extract and route the message(s)           |
+                |                                                |
+                +---------------------+--------------------------+
+                                      |
+                                      |
+                                      |
+                                      +---------------------------+
+                                                                  |
+                                                                  |
+                                                                  |
+                                                                  |  Message routed to the correct
+                                                                  |  module to be processed
+                                                                  |
+                                                                  |
++----------------+  +---------------+  +----------------+  +------v----------+
+|                |  |               |  |                |  |                 |
+|  AUTH MODULE   |  |  BANK MODULE  |  | STAKING MODULE |  |   GOV MODULE    |
+|                |  |               |  |                |  |                 |
+|                |  |               |  |                |  | Handles message,|
+|                |  |               |  |                |  | Updates state   |
+|                |  |               |  |                |  |                 |
++----------------+  +---------------+  +----------------+  +------+----------+
+                                                                  |
+                                                                  |
+                                                                  |
+                                                                  |
+                                       +--------------------------+
+                                       |
+                                       | Return result to Tendermint
+                                       | (0=Ok, 1=Err)
+                                       v
+```
+
+每个模块都可以看做一个小型的状态机。开发人员需要定义模块所处理的状态的自己，已经用作修改状态的message类型(*注意*:message是由`baseapp`的方法从交易中提取的)。通常，每个模块在multistore声明它自己的`KVStore`来持久化保存它所定义的状态子集。大多数开发者在构建自己的模块时也需要访问其他的第三方模块。鉴于Cosmos-SDK是一个开源的框架，一些模块可能是恶意的，这就意味着需要安全原则来合理化模块之间的交互。这些原则基于[object-capabilities](./ocap.md)。实际上，这意味着不是让每个模块保留其他模块的访问控制列表，而是每个模块都实现称作keeper的特殊对象，这些对象可以传递给其他模块并授予预先定义的一组功能。
+
+SDK模块在SDK的`x/`目录下定义。一些核心模块包括：
++ `x/auth`: 用于管理账户和签名.
++ `x/bank`: 用于实现token和token转账.
++ `x/staking` + `x/slashing`: 用于构建POS区块链.
+
+除了`x/`中已有的模块，任何人都可以在他们的应用程序中使用它们自己定义的模块。你可以查看[示例教程](https://cosmos.network/docs/tutorial/keeper.html)。
+
+### 接下来 学习Cosmos SDK的安全模型[ocap](./ocap.md)
diff --git a/docs/translations/kr/clients/lite/getting_started.md b/docs/translations/kr/clients/lite/getting_started.md
index bc5ba1bf3..44ca6a628 100755
--- a/docs/translations/kr/clients/lite/getting_started.md
+++ b/docs/translations/kr/clients/lite/getting_started.md
@@ -20,14 +20,4 @@ gaiacli rest-server --chain-id=test \
     --trust-node=false
 ```
 
-서버는 기본적으로 HTTP를 확인합니다. 보안 계층을 사용하시려면 `--tls` 플래그를 추가해주세요. 기본적으로 자체 서명이 된 인증서가 생성되며, fingerprint가 프린트됩니다. 서버에 특정 SSL 인증서를 사용하기 ㅜ이해서는 `--ssl-certfile`과 `--ssl-keyfile` 플래그를 지정해주세요:
-
-```bash
-gaiacli rest-server --chain-id=test \
-    --laddr=tcp://localhost:1317 \
-    --node tcp://localhost:26657 \
-    --trust-node=false \
-    --ssl-certfile=mycert.pem --ssl-keyfile=mykey.key
-```
-
 Gaia-Lite RPC에 대한 추가적인 정보를 원하시면 [Swagger 문서](https://cosmos.network/rpc/)를 확인하세요.
diff --git a/docs/translations/kr/gaia/delegator-guide-cli.md b/docs/translations/kr/gaia/delegator-guide-cli.md
index 52e93ffbf..f36adebe1 100644
--- a/docs/translations/kr/gaia/delegator-guide-cli.md
+++ b/docs/translations/kr/gaia/delegator-guide-cli.md
@@ -209,7 +209,7 @@ gaiacli keys add <키 명칭 지정(yourKeyName)> --recover --account 1
 
 이 방법이 가장 안전한 방법이지만, 대량의 리소스를 필요로 합니다. 풀노드를 직접 운영하기 위해서는 우수한 인터넷 대역폭과 최소 1TB 상당의 하드디스크 용량을 필요로 합니다.
 
-[풀노드를 운영하는 절차](https://cosmos.network/docs/gaia/join-testnet.html)와 [`gaiad`를 설치하는 방법](https://cosmos.network/docs/gaia/installation.html)은 첨부된 링크를 확인하세요.
+[풀노드를 운영하는 절차](https://cosmos.network/docs/gaia/join-mainnet.html)와 [`gaiad`를 설치하는 방법](https://cosmos.network/docs/gaia/installation.html)은 첨부된 링크를 확인하세요.
 
 ### 외부 풀노드에 연결하기
 
@@ -297,7 +297,32 @@ gaiacli query
 
 각 명령어에는 `-h` 또는 `--help`를 추가하여 관련 정보를 확인하실 수 있습니다.
 
-## 아톰 위임하기 / 리워드 수령하기
+## 트랜잭션 전송하기
+
+::: warning
+코스모스 메인넷에서는 `uatom` 단위가 표준 단위로 사용됩니다. `1atom = 1,000,000uatom`으로 환산됩니다.
+:::
+
+### 가스와 수수료에 대해서
+
+코스모스 허브 네트워크는 트랜잭션 처리를 위해 트랜잭션 수수료를 부과합니다. 해당 수수료는 트랜잭션을 실행하기 위한 가스로 사용됩니다. 공식은 다음과 같습니다:
+
+
+```
+수수료(Fee) = 가스(Gas) * 가스 값(GasPrices)
+```
+
+위 공식에서 `gas`는 전송하는 트랜잭션에 따라 다릅니다. 다른 형태의 트랜잭션은 각자 다른 `gas`량을 필요로 합니다. `gas` 수량은 트랜잭션이 실행될때 계산됨으로 사전에 정확한 값을 확인할 수 있는 방법은 없습니다. 다만, `gas` 플래그의 값을 `auto`로 설정함으로 예상 값을 추출할 수는 있습니다. 예상 값을 수정하기 위해서는 `--gas-adjustment` (기본 값 `1.0`) 플래그 값을 변경하셔서 트랜잭션이 충분한 가스를 확보할 수 있도록 하십시오.
+
+`gasPrice`는 각 `gas` 유닛의 가격입니다. 각 검증인은 직접 최소 가스 가격인 `min-gas-price`를 설정하며, 트랜잭션의 `gasPrice`가 설정한 `min-gas-price`보다 높을때 트랜잭션을 처리합니다.
+
+트랜잭션 피(`fees`)는 `gas` 수량과 `gasPrice`를 곱한 값입니다. 유저는 3개의 값 중 2개의 값을 입력하게 됩니다. `gasPrice`가 높을수록 트랜잭션이 블록에 포함될 확률이 높아집니다.
+
+::: tip
+메인넷 권장 `gas-prices`는 `0.025uatom` 입니다.
+:::
+
+### 아톰 위임하기 / 리워드 수령하기
 
 ::: warning
 **아톰을 위임하기 전에 [위임자 faq](https://cosmos.network/resources/delegators)를 먼저 확인하시고 위임에 따르는 책임과 위험을 사전에 인지하시기 바랍니다**
@@ -309,7 +334,7 @@ gaiacli query
 
 ```bash
 // 아톰 위임하기 
-// 각 플래그 값 예시: <위임할 수량(amountToBound)> = 10000stake, <검증인의 bech32 주소(bech32AddressOfValidator)> = cosmosvaloper18thamkhnj9wz8pa4nhnp9rldprgant57pk2m8s, <가스 가격(gasPrice)> = 0.001stake
+// 각 플래그 값 예시: <위임할 수량(amountToBound)> = 10000uatom, <검증인의 bech32 주소(bech32AddressOfValidator)> = cosmosvaloper18thamkhnj9wz8pa4nhnp9rldprgant57pk2m8s, <가스 가격(gasPrice)> = 0.025uatom
 
 gaiacli tx staking --amount <위임할 수량(amountToBond)> --validator <검증인의 bech32 주소(bech32AddressOfValidator)> --from <위임자 키 명칭(delegatorKeyName)> --gas auto --gas-prices <가스 가격(gasPrice)>
 
@@ -339,21 +364,6 @@ gaiacli query tx <tx 해시값(txHash)>
 
 만약 외부 풀노드를 통해서 블록체인을 사용하신 경우 블록 익스플로러를 통해 트랜잭션을 확인하십시오.
 
-### 가스와 수수료에 대해서
-
-코스모스 허브 네트워크는 트랜잭션 처리를 위해 트랜잭션 수수료를 부과합니다. 해당 수수료는 트랜잭션을 실행하기 위한 가스로 사용됩니다. 공식은 다음과 같습니다:
-
-
-```
-수수료(Fee) = 가스(Gas) * 가스 값(GasPrices)
-```
-
-위 공식에서 `gas`는 전송하는 트랜잭션에 따라 다릅니다. 다른 형태의 트랜잭션은 각자 다른 `gas`량을 필요로 합니다. `gas` 수량은 트랜잭션이 실행될때 계산됨으로 사전에 정확한 값을 확인할 수 있는 방법은 없습니다. 다만, `gas` 플래그의 값을 `auto`로 설정함으로 예상 값을 추출할 수는 있습니다. 예상 값을 수정하기 위해서는 `--gas-adjustment` (기본 값 `1.0`) 플래그 값을 변경하셔서 트랜잭션이 충분한 가스를 확보할 수 있도록 하십시오.
-
-`gasPrice`는 각 `gas` 유닛의 가격입니다. 각 검증인은 직접 최소 가스 가격인 `min-gas-price`를 설정하며, 트랜잭션의 `gasPrice`가 설정한 `min-gas-price`보다 높을때 트랜잭션을 처리합니다.
-
-트랜잭션 피(`fees`)는 `gas` 수량과 `gasPrice`를 곱한 값입니다. 유저는 3개의 값 중 2개의 값을 입력하게 됩니다. `gasPrice`가 높을수록 트랜잭션이 블록에 포함될 확률이 높아집니다.
-
 ## 거버넌스 참가하기
 
 ### 거버넌스에 대해서
@@ -379,13 +389,13 @@ gaiacli query tx <tx 해시값(txHash)>
 ```bash
 // 프로포절 제안하기
 // <프로포절 종류(type)>=text/parameter_change/software_upgrade
-// 플래그 값 예시: <가스 가격(gasPrice)>=0.0001stake
+// 플래그 값 예시: <가스 가격(gasPrice)>=0.025uatom
 
-gaiacli tx gov submit-proposal --title "Test Proposal" --description "My awesome proposal" --type <프로포절 종류(type)> --deposit=10stake --gas auto --gas-prices <가스 가격(gasPrice)> --from <위임자 키 명칭(delegatorKeyName)>
+gaiacli tx gov submit-proposal --title "Test Proposal" --description "My awesome proposal" --type <프로포절 종류(type)> --deposit=10000000uatom --gas auto --gas-prices <가스 가격(gasPrice)> --from <위임자 키 명칭(delegatorKeyName)>
 
 // 프로포절의 예치금 추가하기
 // 프로포절의 proposalID 조회: $gaiacli query gov proposals --status deposit_period
-// 파라미터 값 예시: <예치금(deposit)>=1stake
+// 파라미터 값 예시: <예치금(deposit)>=10000000uatom
 
 gaiacli tx gov deposit <프로포절 ID(proposalID)> <추가할 예치금(deposit)> --gas auto --gas-prices <가스 가격(gasPrice)> --from <위임자 키 명칭(delegatorKeyName)>
 
@@ -402,7 +412,7 @@ gaiacli tx gov vote <프로포절 ID(proposalID)> <표 선택(option)> --gas aut
 
 ```bash
 // 아톰 본딩하기 
-// 플래그 값 예시: <본딩할 수량(amountToBond)>=10000stake, <위임할 검증인의 bech32 주소(bech32AddressOfValidator)>=cosmosvaloper18thamkhnj9wz8pa4nhnp9rldprgant57pk2m8s, <가스 가격(gasPrice)>=0.001stake
+// 플래그 값 예시: <본딩할 수량(amountToBond)>=10000000uatom, <위임할 검증인의 bech32 주소(bech32AddressOfValidator)>=cosmosvaloper18thamkhnj9wz8pa4nhnp9rldprgant57pk2m8s, <가스 가격(gasPrice)>=0.025uatom
 
 gaiacli tx staking --amount <본딩할 수량(amountToBond)> --validator <위임할 검증인의 bech32 주소(bech32AddressOfValidator)> --gas auto --gas-prices <가스 가격(gasPrice)> --generate-only > unsignedTX.json
 ```
diff --git a/docs/translations/kr/gaia/gaiacli.md b/docs/translations/kr/gaia/gaiacli.md
index 3150d8399..546523773 100755
--- a/docs/translations/kr/gaia/gaiacli.md
+++ b/docs/translations/kr/gaia/gaiacli.md
@@ -136,7 +136,7 @@ gaiacli tx send ... --fees=100photino
 또는
 
 ```bash
-gaiacli tx send ... --gas-prices=0.000001stake
+gaiacli tx send ... --gas-prices=1uatom
 ```
 
 ### 계정
@@ -330,12 +330,12 @@ gaiacli query staking validator <account_cosmosval(cosmosval 계정)>
 
 #### 토큰 본딩하기
 
-테스트넷의 경우 `atom`이 아닌 `steak`를 위임합니다. 특정 테스트넷 검증인에게 토큰을 본딩하기 위해서는:
+테스트넷의 경우 `atom`이 아닌 `stake`를 위임합니다. 특정 테스트넷 검증인에게 토큰을 본딩하기 위해서는:
 
 
 ```bash
 gaiacli tx staking delegate \
-  --amount=10steak \
+  --amount=10000000uatom \
   --validator=<validator(검증인 주소)> \
   --from=<key_name(트랜잭션을 발생할 키/계정 이름)> \
   --chain-id=<chain_id(체인 아이디)>
@@ -353,7 +353,7 @@ gaiacli keys show [name] --bech val
 
 
 ::: tip 참고
-보유하고 있는 `steak` 이상을 사용하지 마세요. `steak`가 더 필요한 경우 [Faucet](https://faucetcosmos.network/)에서 추가로 받으실 수 있습니다!
+보유하고 있는 `stake` 이상을 사용하지 마세요. `stake`가 더 필요한 경우 [Faucet](https://faucetcosmos.network/)에서 추가로 받으실 수 있습니다!
 :::
 
 ##### 위임 조회
@@ -371,19 +371,16 @@ gaiacli query staking delegation <delegator_addr(위임자 코스모스 주소)>
 gaiacli query staking delegation <delegator_addr(위임자 코스모스 주소)>
 ```
 
-과거 위임 기록에 대해서는 `--height` 플래그를 추가 하셔서 해당 블록 높이에 대한 기록을 조회하실 수 있습니다.
-
 #### 토큰 언본딩 하기
 
 만약 특정 검증인이 악의적인 행동을 했거나 또는 본인이 개인적인 이유로 일부 토큰을 언본딩을 워하는 경우 다음 명령어를 통해 토큰을 언본딩 할 수 있습니다. 언본딩은 정확한 수량인 `shares-amount`(예시, `12.1`) 또는 언본딩을 원하는 물량의 비율인 `shares-fraction`(예시, `0.25`) 값으로 표현될 수 있습니다.
 
-
 ```bash
 gaiacli tx staking unbond \
-  --validator=<account_cosmosval(검증인 cosmosval 주소)> \
-  --shares-fraction=0.5 \
-  --from=<key_name(트랜잭션을 발생시킬 키/계정 이름)> \
-  --chain-id=<chain_id(체인 아이디)>
+  <validator_addr> \
+  10atom \
+  --from=<key_name> \
+  --chain-id=<chain_id>
 ```
 
 언본딩은 언본딩 기간이 끝나는 대로 완료됩니다.
@@ -408,19 +405,17 @@ gaiacli query staking unbonding-delegations <account_cosmos(위임자 주소)>
 gaiacli query staking unbonding-delegations-from <account_cosmosval(검증인 cosmosval 주소)>
 ```
 
-과거 언본딩 정보는 `--height` 플래그를 통해서 특정 블록 높이에 대한 언본딩 정보를 조회할 수 있습니다.
-
 #### 재위임(Redelegate) 하기
 
 재위임이란 본딩 되어있는 토큰을 한 검증인으로 부터 다른 검증인으로 옮기는 것입니다:
 
 ```bash
 gaiacli tx staking redelegate \
-  --addr-validator-source=<account_cosmosval(스테이킹을 취소할 검증인의 cosmosval 주소)> \
-  --addr-validator-dest=<account_cosmosval(스테이킹을 받을 검증인의 cosmosval 주소)> \
-  --shares-fraction=50 \
-  --from=<key_name(트랜잭션을 발생시킬 키/계정 이름)> \
-  --chain-id=<chain_id(체인 아이디)>
+  <src-validator-operator-addr> \
+  <dst-validator-operator-addr> \
+  10atom \
+  --from=<key_name> \
+  --chain-id=<chain_id>
 ```
 
 위 예시와 같이 재위임될 토큰의 수량은 특정 수량(`shares-amount`) 또는 일정 비율(`shares-fraction`)로 표현될 수 있습니다.
@@ -447,8 +442,6 @@ gaiacli query staking redelegations <account_cosmos(위임자 코스모스 주
   gaiacli query staking redelegations-from <account_cosmosval(검증인 주소)>
 ```
 
-과거 재위임에 대한 정보는 다른 트랜잭션과 동일하게 `--height` 플래그를 이용하여 특정 블록 높이에 대한 재위임 정보를 확인하실 수 있습니다.
-
 #### 파라미터 조회
 
 파라미터는 스테이킹의 하이-레벨 설정을 정의합니다. 현재 값은 다음 명령어를 통해서 조회할 수 있습니다:
@@ -515,7 +508,7 @@ gaiacli tx gov submit-proposal \
   --title=<title(프로포절 제목)> \
   --description=<description(프로포절 설명)> \
   --type=<Text/ParameterChange/SoftwareUpgrade(프로포절 타입)> \
-  --deposit=<40steak(예치금 수량)> \
+  --deposit=<40000000uatom(예치금 수량)> \
   --from=<name(트랜잭션을 발생시킬 키/계정 이름)> \
   --chain-id=<chain_id(체인 아이디)>
 ```
@@ -544,10 +537,10 @@ gaiacli query gov proposer <proposal_id(프로포절 ID)>
 
 #### 보증금 추가하기
 
-프로포절이 네트워크에 전파되기 위해서는 해당 프로포절의 보증금이 `minDeposit` 값 이상이어야 합니다 (현재 기본 값은 `10 steak`입니다). 만약 사전에 생성한 프로포절이 해당 기준을 충족하지 못하였다면 추후에 보증금을 추가 예치하여 활성화할 수 있습니다. 프로포절의 보증금이 최소 값을 도달하면 해당 프로포절의 투표는 활성화 됩니다:
+프로포절이 네트워크에 전파되기 위해서는 해당 프로포절의 보증금이 `minDeposit` 값 이상이어야 합니다 (현재 기본 값은 `10 stake`입니다). 만약 사전에 생성한 프로포절이 해당 기준을 충족하지 못하였다면 추후에 보증금을 추가 예치하여 활성화할 수 있습니다. 프로포절의 보증금이 최소 값을 도달하면 해당 프로포절의 투표는 활성화 됩니다:
 
 ```bash
-gaiacli tx gov deposit <proposal_id(프로포절 ID)> <200steak(금액)> \
+gaiacli tx gov deposit <proposal_id(프로포절 ID)> <200000000uatom(금액)> \
   --from=<name(트랜잭션을 발생시킬 키/계정 이름)> \
   --chain-id=<chain_id(체인 아이디)>
 ```
@@ -688,7 +681,7 @@ gaiacli keys show --address p1p2p3
 위 주소를 기반으로 멀티시그 트랜잭션을 생성하는 과정의 첫 단계는 다음과 같습니다:
 
 ```bash
-gaiacli tx send cosmos1570v2fq3twt0f0x02vhxpuzc9jc4yl30q2qned 10stake \
+gaiacli tx send cosmos1570v2fq3twt0f0x02vhxpuzc9jc4yl30q2qned 10000000uatom \
   --from=<multisig_address(멀티시그 주소)> \
   --generate-only > unsignedTx.json
 ```
diff --git a/docs/translations/kr/gaia/installation.md b/docs/translations/kr/gaia/installation.md
index 4eba582f3..5cfba9dea 100755
--- a/docs/translations/kr/gaia/installation.md
+++ b/docs/translations/kr/gaia/installation.md
@@ -7,10 +7,11 @@
 공식 [Go 문서](https://golang.org/doc/install)를 따라서 `go`를 설치하십시오. `$GOPATH`, `$GOBIN`, 그리고 `$PATH`의 환경을 꼭 세팅하세요. 예시: 
 
 ```bash
-mkdir -p $HOME/go/b4n
+mkdir -p $HOME/go/bin
 echo "export GOPATH=$HOME/go" >> ~/.bash_profile
-echo "export GOBIN=$GOPATH/bin" >> ~/.bash_profile
-echo "export PATH=$PATH:$GOBIN" >> ~/.bash_profile
+echo "export GOBIN=\$GOPATH/bin" >> ~/.bash_profile
+echo "export PATH=\$PATH:\$GOBIN" >> ~/.bash_profile
+source ~/.bash_profile
 ```
 
 ::: tip
diff --git a/docs/translations/kr/gaia/ledger.md b/docs/translations/kr/gaia/ledger.md
index 14ee88f5e..6bb0d0ff0 100755
--- a/docs/translations/kr/gaia/ledger.md
+++ b/docs/translations/kr/gaia/ledger.md
@@ -24,7 +24,7 @@ NAME:	          TYPE:	  ADDRESS:						                                  PUBKEY:
 
 
 ```bash
-$ gaiacli tx send { .Destination.AccAddr } 10stake --from { .Key.Name } --chain-id=gaia-7000
+$ gaiacli tx send { .Destination.AccAddr } 10000000uatom --from { .Key.Name } --chain-id=gaia-7000
 ```
 
 레저 기기에서 해당 트랜잭션을 검토하신 후 서명이 되었다면 트랜잭션 결과를 레저 기기에서 확인하실 수 있습니다.
diff --git a/docs/translations/kr/gaia/validators/validator-setup.md b/docs/translations/kr/gaia/validators/validator-setup.md
index aa105bfc5..f3c27c198 100755
--- a/docs/translations/kr/gaia/validators/validator-setup.md
+++ b/docs/translations/kr/gaia/validators/validator-setup.md
@@ -36,7 +36,7 @@ gaiad tendermint show-validator
 
 ```bash
 gaiacli tx staking create-validator \
-  --amount=5STAKE \
+  --amount=5000000uatom \
   --pubkey=$(gaiad tendermint show-validator) \
   --moniker="choose a moniker" \
   --chain-id=<chain_id> \
diff --git a/go.mod b/go.mod
new file mode 100644
index 000000000..a845f3383
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,56 @@
+module github.com/cosmos/cosmos-sdk
+
+require (
+	bou.ke/monkey v1.0.1 // indirect
+	github.com/VividCortex/gohistogram v1.0.0 // indirect
+	github.com/bartekn/go-bip39 v0.0.0-20171116152956-a05967ea095d
+	github.com/bgentry/speakeasy v0.1.0
+	github.com/btcsuite/btcd v0.0.0-20190115013929-ed77733ec07d
+	github.com/cosmos/go-bip39 v0.0.0-20180618194314-52158e4697b8
+	github.com/cosmos/ledger-cosmos-go v0.9.11
+	github.com/cosmos/ledger-go v0.9.1 // indirect
+	github.com/fortytw2/leaktest v1.3.0 // indirect
+	github.com/go-logfmt/logfmt v0.4.0 // indirect
+	github.com/gogo/protobuf v1.1.1
+	github.com/golang/protobuf v1.2.0
+	github.com/golang/snappy v0.0.1 // indirect
+	github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf // indirect
+	github.com/gorilla/mux v1.7.0
+	github.com/gorilla/websocket v1.4.0 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/jmhodges/levigo v1.0.0 // indirect
+	github.com/magiconair/properties v1.8.0 // indirect
+	github.com/mattn/go-isatty v0.0.6
+	github.com/mitchellh/mapstructure v1.1.2 // indirect
+	github.com/otiai10/copy v0.0.0-20180813032824-7e9a647135a1
+	github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95 // indirect
+	github.com/otiai10/mint v1.2.3 // indirect
+	github.com/pelletier/go-toml v1.2.0
+	github.com/pkg/errors v0.8.0
+	github.com/prometheus/client_golang v0.9.2 // indirect
+	github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 // indirect
+	github.com/prometheus/common v0.2.0 // indirect
+	github.com/prometheus/procfs v0.0.0-20190227231451-bbced9601137 // indirect
+	github.com/rakyll/statik v0.1.4
+	github.com/rcrowley/go-metrics v0.0.0-20180503174638-e2704e165165 // indirect
+	github.com/rs/cors v1.6.0 // indirect
+	github.com/spf13/afero v1.2.1 // indirect
+	github.com/spf13/cast v1.3.0 // indirect
+	github.com/spf13/cobra v0.0.3
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
+	github.com/spf13/pflag v1.0.3
+	github.com/spf13/viper v1.0.3
+	github.com/stretchr/testify v1.2.2
+	github.com/syndtr/goleveldb v0.0.0-20180708030551-c4c61651e9e3 // indirect
+	github.com/tendermint/btcd v0.1.1
+	github.com/tendermint/go-amino v0.14.1
+	github.com/tendermint/iavl v0.12.1
+	github.com/tendermint/tendermint v0.31.4
+	github.com/zondax/hid v0.9.0 // indirect
+	golang.org/x/crypto v0.0.0-20180904163835-0709b304e793
+	google.golang.org/grpc v1.19.0 // indirect
+	gopkg.in/yaml.v2 v2.2.2 // indirect
+)
+
+replace golang.org/x/crypto => github.com/tendermint/crypto v0.0.0-20180820045704-3764759f34a5
diff --git a/go.sum b/go.sum
new file mode 100644
index 000000000..f7fe4d278
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,189 @@
+bou.ke/monkey v1.0.1 h1:zEMLInw9xvNakzUUPjfS4Ds6jYPqCFx3m7bRmG5NH2U=
+bou.ke/monkey v1.0.1/go.mod h1:FgHuK96Rv2Nlf+0u1OOVDpCMdsWyOFmeeketDHE7LIg=
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
+github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
+github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/bartekn/go-bip39 v0.0.0-20171116152956-a05967ea095d h1:1aAija9gr0Hyv4KfQcRcwlmFIrhkDmIj2dz5bkg/s/8=
+github.com/bartekn/go-bip39 v0.0.0-20171116152956-a05967ea095d/go.mod h1:icNx/6QdFblhsEjZehARqbNumymUT/ydwlLojFdv7Sk=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 h1:xJ4a3vCFaGF/jqvzLMYoU8P317H5OQ+Via4RmuPwCS0=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY=
+github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/btcsuite/btcd v0.0.0-20190115013929-ed77733ec07d h1:xG8Pj6Y6J760xwETNmMzmlt38QSwz0BLp1cZ09g27uw=
+github.com/btcsuite/btcd v0.0.0-20190115013929-ed77733ec07d/go.mod h1:d3C0AkH6BRcvO8T0UEPu53cnw4IbV63x1bEjildYhO0=
+github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
+github.com/btcsuite/btcutil v0.0.0-20180706230648-ab6388e0c60a h1:RQMUrEILyYJEoAT34XS/kLu40vC0+po/UfxrBBA4qZE=
+github.com/btcsuite/btcutil v0.0.0-20180706230648-ab6388e0c60a/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
+github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg=
+github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY=
+github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
+github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
+github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cosmos/go-bip39 v0.0.0-20180618194314-52158e4697b8 h1:Iwin12wRQtyZhH6FV3ykFcdGNlYEzoeR0jN8Vn+JWsI=
+github.com/cosmos/go-bip39 v0.0.0-20180618194314-52158e4697b8/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y=
+github.com/cosmos/ledger-cosmos-go v0.9.11 h1:bkcIKqaM6evicjkSP+Le8HDLXt9P+MqGRnGiMUC20m4=
+github.com/cosmos/ledger-cosmos-go v0.9.11/go.mod h1:RWldjvUf4Hfi46ti/8etBH3eQ2rOqqz2hstdzROQSHo=
+github.com/cosmos/ledger-go v0.9.1 h1:bRIamtlWShVk1THw52NdCPHxtBxKnauglSB23mH1/w8=
+github.com/cosmos/ledger-go v0.9.1/go.mod h1:oZJ2hHAZROdlHiwTg4t7kP+GKIIkBT+o6c9QWFanOyI=
+github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw=
+github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/go-kit/kit v0.8.0 h1:Wz+5lgoB0kkuqLEc6NVmwRknTKP6dTGbSqvhZtBI/j0=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0 h1:MP4Eh7ZCb31lleYCFuwm0oe4/YGak+5l1vA2NOE80nA=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf h1:+RRA9JqSOZFfKrOeqr2z77+8R2RKyh8PG66dcu1V0ck=
+github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
+github.com/gorilla/mux v1.7.0 h1:tOSd0UKHQd6urX6ApfOn4XdBMY6Sh1MfxV3kmaazO+U=
+github.com/gorilla/mux v1.7.0/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U=
+github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
+github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/mattn/go-isatty v0.0.6 h1:SrwhHcpV4nWrMGdNcC2kXpMfcBVYGDuTArqyhocJgvA=
+github.com/mattn/go-isatty v0.0.6/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/otiai10/copy v0.0.0-20180813032824-7e9a647135a1 h1:A7kMXwDPBTfIVRv2l6XV3U6Su3SzLUzZjxnDDQVZDIY=
+github.com/otiai10/copy v0.0.0-20180813032824-7e9a647135a1/go.mod h1:pXzZSDlN+HPzSdyIBnKNN9ptD9Hx7iZMWIJPTwo4FPE=
+github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95 h1:+OLn68pqasWca0z5ryit9KGfp3sUsW4Lqg32iRMJyzs=
+github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE=
+github.com/otiai10/mint v1.2.3 h1:PsrRBmrxR68kyNu6YlqYHbNlItc5vOkuS6LBEsNttVA=
+github.com/otiai10/mint v1.2.3/go.mod h1:YnfyPNhBvnY8bW4SGQHCs/aAFhkgySlMZbrF5U0bOVw=
+github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.2 h1:awm861/B8OKDd2I/6o1dy3ra4BamzKhYOiGItCeZ740=
+github.com/prometheus/client_golang v0.9.2/go.mod h1:OsXs2jCmiKlQ1lTBmv21f2mNfw4xf/QclQDMrYNZzcM=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.2.0 h1:kUZDBDTdBVBYBj5Tmh2NZLlF60mfjA27rM34b+cVwNU=
+github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190227231451-bbced9601137 h1:3l8oligPtjd4JuM+OZ+U8sjtwFGJs98cdWsqs6QZRWs=
+github.com/prometheus/procfs v0.0.0-20190227231451-bbced9601137/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/rakyll/statik v0.1.4 h1:zCS/YQCxfo/fQjCtGVGIyWGFnRbQ18Y55mhS3XPE+Oo=
+github.com/rakyll/statik v0.1.4/go.mod h1:OEi9wJV/fMUAGx1eNjq75DKDsJVuEv1U0oYdX6GX8Zs=
+github.com/rcrowley/go-metrics v0.0.0-20180503174638-e2704e165165 h1:nkcn14uNmFEuGCb2mBZbBb24RdNRL08b/wb+xBOYpuk=
+github.com/rcrowley/go-metrics v0.0.0-20180503174638-e2704e165165/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/rs/cors v1.6.0 h1:G9tHG9lebljV9mfp9SNPDL36nCDxmo3zTlAf1YgvzmI=
+github.com/rs/cors v1.6.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/spf13/afero v1.2.1 h1:qgMbHoJbPbw579P+1zVY+6n4nIFuIchaIjzZ/I/Yq8M=
+github.com/spf13/afero v1.2.1/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
+github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8=
+github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
+github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/viper v1.0.3 h1:z5LPUc2iz8VLT5Cw1UyrESG6FUUnOGecYGY08BLKSuc=
+github.com/spf13/viper v1.0.3/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/syndtr/goleveldb v0.0.0-20180708030551-c4c61651e9e3 h1:sAlSBRDl4psFR3ysKXRSE8ss6Mt90+ma1zRTroTNBJA=
+github.com/syndtr/goleveldb v0.0.0-20180708030551-c4c61651e9e3/go.mod h1:Z4AUp2Km+PwemOoO/VB5AOx9XSsIItzFjoJlOSiYmn0=
+github.com/tendermint/btcd v0.1.1 h1:0VcxPfflS2zZ3RiOAHkBiFUcPvbtRj5O7zHmcJWHV7s=
+github.com/tendermint/btcd v0.1.1/go.mod h1:DC6/m53jtQzr/NFmMNEu0rxf18/ktVoVtMrnDD5pN+U=
+github.com/tendermint/crypto v0.0.0-20180820045704-3764759f34a5 h1:u8i49c+BxloX3XQ55cvzFNXplizZP/q00i+IlttUjAU=
+github.com/tendermint/crypto v0.0.0-20180820045704-3764759f34a5/go.mod h1:z4YtwM70uOnk8h0pjJYlj3zdYwi9l03By6iAIF5j/Pk=
+github.com/tendermint/go-amino v0.14.1 h1:o2WudxNfdLNBwMyl2dqOJxiro5rfrEaU0Ugs6offJMk=
+github.com/tendermint/go-amino v0.14.1/go.mod h1:i/UKE5Uocn+argJJBb12qTZsCDBcAYMbR92AaJVmKso=
+github.com/tendermint/iavl v0.12.1 h1:JDfyhM/Hhrumu1CL1Nxrypm8sNTPYqmeHo1IZLiJoXM=
+github.com/tendermint/iavl v0.12.1/go.mod h1:EoKMMv++tDOL5qKKVnoIqtVPshRrEPeJ0WsgDOLAauM=
+github.com/tendermint/tendermint v0.31.4 h1:F/vZ/fMHZJriAkDLjf9ZrReJQsuELiTmJLqigmbE5NU=
+github.com/tendermint/tendermint v0.31.4/go.mod h1:ymcPyWblXCplCPQjbOYbrF1fWnpslATMVqiGgWbZrlc=
+github.com/zondax/hid v0.9.0 h1:eiT3P6vNxAEVxXMw66eZUAAnU2zD33JBkfG/EnfAKl8=
+github.com/zondax/hid v0.9.0/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc h1:a3CU5tJYVj92DY2LaA1kUkrsqD5/3mLDhx2NcNqyW+0=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 h1:YUO/7uOKsKeq9UokNS62b8FYywz3ker1l1vDZRCRefw=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223 h1:DH4skfRX4EBpamg7iV4ZlCpblAHI6s6TDM39bFZumv8=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b h1:qMK98NmNCRVDIYFycQ5yVRkvgDUFfdP8Ip4KqmDEB7g=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/grpc v1.19.0 h1:cfg4PD8YEdSFnm7qLV4++93WcmhH2nIUhMjhdCvl3j8=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
diff --git a/scripts/Makefile b/scripts/Makefile
index 4a0a7d157..d76720d40 100644
--- a/scripts/Makefile
+++ b/scripts/Makefile
@@ -17,6 +17,8 @@ endif
 
 GOPATH ?= $(shell $(GO) env GOPATH)
 GITHUBDIR := $(GOPATH)$(FS)src$(FS)github.com
+GOLANGCI_LINT_VERSION := v1.15.0
+GOLANGCI_LINT_HASHSUM := ac897cadc180bf0c1a4bf27776c410debad27205b22856b861d41d39d06509cf
 
 ###
 # Functions
@@ -33,27 +35,35 @@ cd $(GITHUBDIR)$(FS)$(1)$(FS)$(2) && git fetch origin && git checkout -q $(3)
 
 go_install = $(call go_get,$(1),$(2),$(3)) && cd $(GITHUBDIR)$(FS)$(1)$(FS)$(2) && $(GO) install
 
+mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
+mkfile_dir := $(shell cd $(shell dirname $(mkfile_path)); pwd)
+
 ###
 # tools
 ###
 all: tools
-tools: $(GOPATH)/bin/dep $(GOPATH)/bin/gometalinter $(GOPATH)/bin/statik $(GOPATH)/bin/goimports
 
-$(GOPATH)/bin/dep:
-	$(call go_get,golang,dep,22125cfaa6ddc71e145b1535d4b7ee9744fefff2)
-	cd $(GITHUBDIR)$(FS)golang$(FS)dep$(FS)cmd$(FS)dep && $(GO) install
+tools: tools-stamp
+tools-stamp: $(GOBIN)/golangci-lint $(GOBIN)/statik $(GOBIN)/goimports $(GOBIN)/gosum $(GOBIN)/sdkch
+	touch $@
 
-#v2.0.11
-$(GOPATH)/bin/gometalinter:
-	$(call go_install,alecthomas,gometalinter,v3.0.0)
+$(GOBIN)/golangci-lint: contrib/install-golangci-lint.sh $(GOBIN)/gosum
+	bash contrib/install-golangci-lint.sh $(GOBIN) $(GOLANGCI_LINT_VERSION) $(GOLANGCI_LINT_HASHSUM)
 
-$(GOPATH)/bin/statik:
+$(GOBIN)/statik:
 	$(call go_install,rakyll,statik,v0.1.5)
 
-$(GOPATH)/bin/goimports:
-	go get golang.org/x/tools/cmd/goimports
+$(GOBIN)/goimports:
+	go get golang.org/x/tools/cmd/goimports@v0.0.0-20190114222345-bf090417da8b
+
+$(GOBIN)/gosum:
+	go install -mod=readonly ./cmd/gosum/
+
+$(GOBIN)/sdkch:
+	go install -mod=readonly ./cmd/sdkch/
 
 tools-clean:
-	cd $(GOPATH)/bin && rm -f dep gometalinter statik goimports
+	cd $(GOBIN) && rm -f golangci-lint statik goimports gosum sdkch
+	rm -f tools-stamp
 
-.PHONY: all clean-tools
+.PHONY: all tools tools-clean
diff --git a/scripts/install/install_sdk_arm.sh b/scripts/install/install_sdk_arm.sh
index f7aa0ec86..ef9e56ece 100644
--- a/scripts/install/install_sdk_arm.sh
+++ b/scripts/install/install_sdk_arm.sh
@@ -4,7 +4,7 @@
 BRANCH=master
 REPO=github.com/cosmos/cosmos-sdk
 
-GO_VERSION=1.11.5
+GO_VERSION=1.12.1
 
 sudo apt-get update -y
 sudo apt-get upgrade -y
diff --git a/scripts/install/install_sdk_bsd.sh b/scripts/install/install_sdk_bsd.sh
index 684274e99..4784addc3 100644
--- a/scripts/install/install_sdk_bsd.sh
+++ b/scripts/install/install_sdk_bsd.sh
@@ -16,7 +16,7 @@
 set BRANCH=master
 set REPO=github.com/cosmos/cosmos-sdk
 
-set GO_VERSION=1.11.5
+set GO_VERSION=1.12.1
 
 sudo pkg update
 
diff --git a/scripts/install/install_sdk_ubuntu.sh b/scripts/install/install_sdk_ubuntu.sh
index 9d235f41c..079eed831 100644
--- a/scripts/install/install_sdk_ubuntu.sh
+++ b/scripts/install/install_sdk_ubuntu.sh
@@ -7,7 +7,7 @@
 BRANCH=master
 REPO=github.com/cosmos/cosmos-sdk
 
-GO_VERSION=1.11.5
+GO_VERSION=1.12.1
 
 sudo apt-get update -y
 sudo apt-get upgrade -y
diff --git a/scripts/multisim.sh b/scripts/multisim.sh
index e8df463dc..9ff71c567 100755
--- a/scripts/multisim.sh
+++ b/scripts/multisim.sh
@@ -1,5 +1,7 @@
 #!/bin/bash
 
+go mod download
+
 seeds=(1 2 4 7 9 20 32 123 124 582 1893 2989 3012 4728 37827 981928 87821 891823782 989182 89182391 \
 11 22 44 77 99 2020 3232 123123 124124 582582 18931893 29892989 30123012 47284728 37827)
 blocks=$1
diff --git a/server/config/config.go b/server/config/config.go
index 6afde66f0..11ff53488 100644
--- a/server/config/config.go
+++ b/server/config/config.go
@@ -2,6 +2,7 @@ package config
 
 import (
 	"fmt"
+	"strings"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -14,7 +15,7 @@ const (
 type BaseConfig struct {
 	// The minimum gas prices a validator is willing to accept for processing a
 	// transaction. A transaction's fees must meet the minimum of any denomination
-	// specified in this config (e.g. 0.01photino;0.0001stake).
+	// specified in this config (e.g. 0.25token1;0.0001token2).
 	MinGasPrices string `mapstructure:"minimum-gas-prices"`
 }
 
@@ -31,9 +32,20 @@ func (c *Config) SetMinGasPrices(gasPrices sdk.DecCoins) {
 // GetMinGasPrices returns the validator's minimum gas prices based on the set
 // configuration.
 func (c *Config) GetMinGasPrices() sdk.DecCoins {
-	gasPrices, err := sdk.ParseDecCoins(c.MinGasPrices)
-	if err != nil {
-		panic(fmt.Sprintf("invalid minimum gas prices: %v", err))
+	if c.MinGasPrices == "" {
+		return sdk.DecCoins{}
+	}
+
+	gasPricesStr := strings.Split(c.MinGasPrices, ";")
+	gasPrices := make(sdk.DecCoins, len(gasPricesStr))
+
+	for i, s := range gasPricesStr {
+		gasPrice, err := sdk.ParseDecCoin(s)
+		if err != nil {
+			panic(fmt.Errorf("failed to parse minimum gas price coin (%s): %s", s, err))
+		}
+
+		gasPrices[i] = gasPrice
 	}
 
 	return gasPrices
diff --git a/server/config/toml.go b/server/config/toml.go
index 1841393ab..31e6ea9bc 100644
--- a/server/config/toml.go
+++ b/server/config/toml.go
@@ -15,7 +15,7 @@ const defaultConfigTemplate = `# This is a TOML config file.
 
 # The minimum gas prices a validator is willing to accept for processing a
 # transaction. A transaction's fees must meet the minimum of any denomination
-# specified in this config (e.g. 0.01photino;0.0001stake).
+# specified in this config (e.g. 0.25token1;0.0001token2).
 minimum-gas-prices = "{{ .BaseConfig.MinGasPrices }}"
 `
 
diff --git a/snapcraft.yaml b/snapcraft.yaml
index beb770c7d..912aa50f6 100644
--- a/snapcraft.yaml
+++ b/snapcraft.yaml
@@ -33,12 +33,13 @@ parts:
     build-snaps: [go]
     override-build: |
         base=`pwd`
+        export GO111MODULE=on
         export GOPATH=`pwd`/go
         export GOBIN=$GOPATH/bin
         export PATH=$GOBIN:$PATH
         cd $GOPATH/src/github.com/cosmos/cosmos-sdk
+        make go-mod-cache
         make tools
-        make vendor-deps
         make install
         mkdir $SNAPCRAFT_PART_INSTALL/bin
         cp $GOPATH/bin/gaiad $SNAPCRAFT_PART_INSTALL/bin
diff --git a/tools/gometalinter.json b/tools/gometalinter.json
deleted file mode 100644
index fe1084821..000000000
--- a/tools/gometalinter.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "Linters": {
-        "vet": "go tool vet -composites=false :PATH:LINE:MESSAGE"
-   },
-    "Enable": ["golint", "vet", "ineffassign", "unconvert", "misspell"],
-    "Deadline": "500s",
-    "Vendor": true,
-    "Cyclo": 11,
-    "Exclude": ["/usr/lib/go/src/", "client/lcd/statik/statik.go", "vendor/*"]
-}
diff --git a/types/coin.go b/types/coin.go
index 365e0f2ef..4c6ef53f7 100644
--- a/types/coin.go
+++ b/types/coin.go
@@ -1,7 +1,6 @@
 package types
 
 import (
-	"errors"
 	"fmt"
 	"regexp"
 	"sort"
@@ -130,6 +129,28 @@ func (coin Coin) IsNegative() bool {
 // Coins is a set of Coin, one per currency
 type Coins []Coin
 
+// NewCoins constructs a new coin set.
+func NewCoins(coins ...Coin) Coins {
+	// remove zeroes
+	newCoins := removeZeroCoins(Coins(coins))
+	if len(newCoins) == 0 {
+		return Coins{}
+	}
+
+	newCoins.Sort()
+
+	// detect duplicate Denoms
+	if dupIndex := findDup(newCoins); dupIndex != -1 {
+		panic(fmt.Errorf("find duplicate denom: %s", newCoins[dupIndex]))
+	}
+
+	if !newCoins.IsValid() {
+		panic(fmt.Errorf("invalid coin set: %s", newCoins))
+	}
+
+	return newCoins
+}
+
 func (coins Coins) String() string {
 	if len(coins) == 0 {
 		return ""
@@ -247,6 +268,23 @@ func (coins Coins) safeAdd(coinsB Coins) Coins {
 	}
 }
 
+// DenomsSubsetOf returns true if receiver's denom set
+// is subset of coinsB's denoms.
+func (coins Coins) DenomsSubsetOf(coinsB Coins) bool {
+	// more denoms in B than in receiver
+	if len(coins) > len(coinsB) {
+		return false
+	}
+
+	for _, coin := range coins {
+		if coinsB.AmountOf(coin.Denom).IsZero() {
+			return false
+		}
+	}
+
+	return true
+}
+
 // Sub subtracts a set of coins from another.
 //
 // e.g.
@@ -272,26 +310,50 @@ func (coins Coins) SafeSub(coinsB Coins) (Coins, bool) {
 	return diff, diff.IsAnyNegative()
 }
 
-// IsAllGT returns true if for every denom in coins, the denom is present at a
-// greater amount in coinsB.
+// IsAllGT returns true if for every denom in coinsB,
+// the denom is present at a greater amount in coins.
 func (coins Coins) IsAllGT(coinsB Coins) bool {
-	diff, _ := coins.SafeSub(coinsB)
-	if len(diff) == 0 {
+	if len(coins) == 0 {
 		return false
 	}
 
-	return diff.IsAllPositive()
-}
-
-// IsAllGTE returns true iff for every denom in coins, the denom is present at
-// an equal or greater amount in coinsB.
-func (coins Coins) IsAllGTE(coinsB Coins) bool {
-	diff, _ := coins.SafeSub(coinsB)
-	if len(diff) == 0 {
+	if len(coinsB) == 0 {
 		return true
 	}
 
-	return !diff.IsAnyNegative()
+	if !coinsB.DenomsSubsetOf(coins) {
+		return false
+	}
+
+	for _, coinB := range coinsB {
+		amountA, amountB := coins.AmountOf(coinB.Denom), coinB.Amount
+		if !amountA.GT(amountB) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// IsAllGTE returns false if for any denom in coinsB,
+// the denom is present at a smaller amount in coins;
+// else returns true.
+func (coins Coins) IsAllGTE(coinsB Coins) bool {
+	if len(coinsB) == 0 {
+		return true
+	}
+
+	if len(coins) == 0 {
+		return false
+	}
+
+	for _, coinB := range coinsB {
+		if coinB.Amount.GT(coins.AmountOf(coinB.Denom)) {
+			return false
+		}
+	}
+
+	return true
 }
 
 // IsAllLT returns True iff for every denom in coins, the denom is present at
@@ -489,7 +551,7 @@ var (
 
 func validateDenom(denom string) error {
 	if !reDnm.MatchString(denom) {
-		return errors.New("illegal characters")
+		return fmt.Errorf("invalid denom: %s", denom)
 	}
 	return nil
 }
@@ -527,28 +589,46 @@ func ParseCoin(coinStr string) (coin Coin, err error) {
 // ParseCoins will parse out a list of coins separated by commas.
 // If nothing is provided, it returns nil Coins.
 // Returned coins are sorted.
-func ParseCoins(coinsStr string) (coins Coins, err error) {
+func ParseCoins(coinsStr string) (Coins, error) {
 	coinsStr = strings.TrimSpace(coinsStr)
 	if len(coinsStr) == 0 {
 		return nil, nil
 	}
 
 	coinStrs := strings.Split(coinsStr, ",")
-	for _, coinStr := range coinStrs {
+	coins := make(Coins, len(coinStrs))
+	for i, coinStr := range coinStrs {
 		coin, err := ParseCoin(coinStr)
 		if err != nil {
 			return nil, err
 		}
-		coins = append(coins, coin)
+
+		coins[i] = coin
 	}
 
-	// Sort coins for determinism.
+	// sort coins for determinism
 	coins.Sort()
 
-	// Validate coins before returning.
+	// validate coins before returning
 	if !coins.IsValid() {
 		return nil, fmt.Errorf("parseCoins invalid: %#v", coins)
 	}
 
 	return coins, nil
 }
+
+// findDup works on the assumption that coins is sorted
+func findDup(coins Coins) int {
+	if len(coins) <= 1 {
+		return -1
+	}
+
+	prevDenom := coins[0]
+	for i := 1; i < len(coins); i++ {
+		if coins[i] == prevDenom {
+			return i
+		}
+	}
+
+	return -1
+}
diff --git a/types/coin_test.go b/types/coin_test.go
index 50dd8bb52..a9ebdad96 100644
--- a/types/coin_test.go
+++ b/types/coin_test.go
@@ -34,7 +34,7 @@ func TestIsEqualCoin(t *testing.T) {
 	}{
 		{NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom1, 1), true, false},
 		{NewInt64Coin(testDenom1, 1), NewInt64Coin(testDenom2, 1), false, true},
-		{NewInt64Coin("steak", 1), NewInt64Coin("steak", 10), false, false},
+		{NewInt64Coin("stake", 1), NewInt64Coin("stake", 10), false, false},
 	}
 
 	for tcIndex, tc := range cases {
@@ -276,10 +276,7 @@ func TestCoins(t *testing.T) {
 	mixedCase3 := Coins{
 		{"gAs", NewInt(1)},
 	}
-	empty := Coins{
-		{"gold", NewInt(0)},
-	}
-	null := Coins{}
+	empty := NewCoins()
 	badSort1 := Coins{
 		{"tree", NewInt(1)},
 		{"gas", NewInt(1)},
@@ -312,7 +309,7 @@ func TestCoins(t *testing.T) {
 	assert.False(t, mixedCase2.IsValid(), "First Coins denoms contain upper case characters")
 	assert.False(t, mixedCase3.IsValid(), "Single denom in Coins contains upper case characters")
 	assert.True(t, good.IsAllPositive(), "Expected coins to be positive: %v", good)
-	assert.False(t, null.IsAllPositive(), "Expected coins to not be positive: %v", null)
+	assert.False(t, empty.IsAllPositive(), "Expected coins to not be positive: %v", empty)
 	assert.True(t, good.IsAllGTE(empty), "Expected %v to be >= %v", good, empty)
 	assert.False(t, good.IsAllLT(empty), "Expected %v to be < %v", good, empty)
 	assert.True(t, empty.IsAllLT(good), "Expected %v to be < %v", empty, good)
@@ -331,22 +328,10 @@ func TestCoinsGT(t *testing.T) {
 	assert.True(t, Coins{{testDenom1, one}}.IsAllGT(Coins{}))
 	assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom1, one}}))
 	assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom2, one}}))
-	assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(Coins{{testDenom2, one}}))
+	assert.True(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(Coins{{testDenom2, one}}))
 	assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(Coins{{testDenom2, two}}))
 }
 
-func TestCoinsGTE(t *testing.T) {
-	one := NewInt(1)
-	two := NewInt(2)
-
-	assert.True(t, Coins{}.IsAllGTE(Coins{}))
-	assert.True(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{}))
-	assert.True(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom1, one}}))
-	assert.False(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom2, one}}))
-	assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(Coins{{testDenom2, one}}))
-	assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(Coins{{testDenom2, two}}))
-}
-
 func TestCoinsLT(t *testing.T) {
 	one := NewInt(1)
 	two := NewInt(2)
@@ -358,7 +343,7 @@ func TestCoinsLT(t *testing.T) {
 	assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom2, one}}))
 	assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom2, two}}))
 	assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom1, one}, {testDenom2, one}}))
-	assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllLT(Coins{{testDenom1, two}, {testDenom2, two}}))
 	assert.True(t, Coins{}.IsAllLT(Coins{{testDenom1, one}}))
 }
 
@@ -519,3 +504,73 @@ func TestCoinsIsAnyGTE(t *testing.T) {
 	assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAnyGTE(Coins{{testDenom1, one}, {testDenom2, two}}))
 	assert.True(t, Coins{{"xxx", one}, {"yyy", one}}.IsAnyGTE(Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
 }
+
+func TestCoinsIsAllGT(t *testing.T) {
+	one := NewInt(1)
+	two := NewInt(2)
+
+	assert.False(t, Coins{}.IsAllGT(Coins{}))
+	assert.True(t, Coins{{testDenom1, one}}.IsAllGT(Coins{}))
+	assert.False(t, Coins{}.IsAllGT(Coins{{testDenom1, one}}))
+	assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom1, two}}))
+	assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom2, one}}))
+	assert.False(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(Coins{{testDenom1, two}, {testDenom2, one}}))
+	assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom1, one}}))
+	assert.True(t, Coins{{testDenom1, two}}.IsAllGT(Coins{{testDenom1, one}}))
+	assert.False(t, Coins{{testDenom1, one}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.False(t, Coins{{testDenom2, two}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.False(t, Coins{{testDenom2, one}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.False(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, one}}))
+	assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGT(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.False(t, Coins{{"xxx", one}, {"yyy", one}}.IsAllGT(Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
+}
+
+func TestCoinsIsAllGTE(t *testing.T) {
+	one := NewInt(1)
+	two := NewInt(2)
+
+	assert.True(t, Coins{}.IsAllGTE(Coins{}))
+	assert.True(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{}))
+	assert.True(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(Coins{{testDenom2, one}}))
+	assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(Coins{{testDenom2, two}}))
+	assert.False(t, Coins{}.IsAllGTE(Coins{{testDenom1, one}}))
+	assert.False(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom1, two}}))
+	assert.False(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom2, one}}))
+	assert.False(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGTE(Coins{{testDenom1, two}, {testDenom2, one}}))
+	assert.True(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom1, one}}))
+	assert.True(t, Coins{{testDenom1, two}}.IsAllGTE(Coins{{testDenom1, one}}))
+	assert.False(t, Coins{{testDenom1, one}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.False(t, Coins{{testDenom2, two}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.False(t, Coins{{testDenom2, one}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.True(t, Coins{{testDenom1, one}, {testDenom2, two}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, one}}))
+	assert.False(t, Coins{{testDenom1, one}, {testDenom2, one}}.IsAllGTE(Coins{{testDenom1, one}, {testDenom2, two}}))
+	assert.False(t, Coins{{"xxx", one}, {"yyy", one}}.IsAllGTE(Coins{{testDenom2, one}, {"ccc", one}, {"yyy", one}, {"zzz", one}}))
+}
+
+func TestNewCoins(t *testing.T) {
+	tenatom := NewInt64Coin("atom", 10)
+	tenbtc := NewInt64Coin("btc", 10)
+	zeroeth := NewInt64Coin("eth", 0)
+	tests := []struct {
+		name      string
+		coins     Coins
+		want      Coins
+		wantPanic bool
+	}{
+		{"empty args", []Coin{}, Coins{}, false},
+		{"one coin", []Coin{tenatom}, Coins{tenatom}, false},
+		{"sort after create", []Coin{tenbtc, tenatom}, Coins{tenatom, tenbtc}, false},
+		{"sort and remove zeroes", []Coin{zeroeth, tenbtc, tenatom}, Coins{tenatom, tenbtc}, false},
+		{"panic on dups", []Coin{tenatom, tenatom}, Coins{}, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.wantPanic {
+				require.Panics(t, func() { NewCoins(tt.coins...) })
+				return
+			}
+			got := NewCoins(tt.coins...)
+			require.True(t, got.IsEqual(tt.want))
+		})
+	}
+}
diff --git a/types/dec_coin.go b/types/dec_coin.go
index 19d5db2bd..1ecfd8260 100644
--- a/types/dec_coin.go
+++ b/types/dec_coin.go
@@ -2,7 +2,6 @@ package types
 
 import (
 	"fmt"
-	"regexp"
 	"sort"
 	"strings"
 
@@ -114,7 +113,8 @@ func (coin DecCoin) Sub(coinB DecCoin) DecCoin {
 	return DecCoin{coin.Denom, coin.Amount.Sub(coinB.Amount)}
 }
 
-// return the decimal coins with trunctated decimals, and return the change
+// TruncateDecimal returns a Coin with a truncated decimal and a DecCoin for the
+// change. Note, the change may be zero.
 func (coin DecCoin) TruncateDecimal() (Coin, DecCoin) {
 	truncated := coin.Amount.TruncateInt()
 	change := coin.Amount.Sub(truncated.ToDec())
@@ -171,18 +171,20 @@ func (coins DecCoins) String() string {
 }
 
 // TruncateDecimal returns the coins with truncated decimals and returns the
-// change.
-func (coins DecCoins) TruncateDecimal() (Coins, DecCoins) {
-	changeSum := DecCoins{}
-	out := make(Coins, len(coins))
-
-	for i, coin := range coins {
+// change. Note, it will not return any zero-amount coins in either the truncated or
+// change coins.
+func (coins DecCoins) TruncateDecimal() (truncatedCoins Coins, changeCoins DecCoins) {
+	for _, coin := range coins {
 		truncated, change := coin.TruncateDecimal()
-		out[i] = truncated
-		changeSum = changeSum.Add(DecCoins{change})
+		if !truncated.IsZero() {
+			truncatedCoins = truncatedCoins.Add(Coins{truncated})
+		}
+		if !change.IsZero() {
+			changeCoins = changeCoins.Add(DecCoins{change})
+		}
 	}
 
-	return out, changeSum
+	return truncatedCoins, changeCoins
 }
 
 // Add adds two sets of DecCoins.
@@ -310,55 +312,90 @@ func (coins DecCoins) IsAnyNegative() bool {
 	return false
 }
 
-// multiply all the coins by a decimal
+// MulDec multiplies all the coins by a decimal.
+//
+// CONTRACT: No zero coins will be returned.
 func (coins DecCoins) MulDec(d Dec) DecCoins {
-	res := make([]DecCoin, len(coins))
-	for i, coin := range coins {
+	var res DecCoins
+	for _, coin := range coins {
 		product := DecCoin{
 			Denom:  coin.Denom,
 			Amount: coin.Amount.Mul(d),
 		}
-		res[i] = product
+
+		if !product.IsZero() {
+			res = res.Add(DecCoins{product})
+		}
 	}
+
 	return res
 }
 
-// multiply all the coins by a decimal, truncating
+// MulDecTruncate multiplies all the decimal coins by a decimal, truncating. It
+// panics if d is zero.
+//
+// CONTRACT: No zero coins will be returned.
 func (coins DecCoins) MulDecTruncate(d Dec) DecCoins {
-	res := make([]DecCoin, len(coins))
-	for i, coin := range coins {
+	var res DecCoins
+
+	for _, coin := range coins {
 		product := DecCoin{
 			Denom:  coin.Denom,
 			Amount: coin.Amount.MulTruncate(d),
 		}
-		res[i] = product
+
+		if !product.IsZero() {
+			res = res.Add(DecCoins{product})
+		}
 	}
+
 	return res
 }
 
-// divide all the coins by a decimal
+// QuoDec divides all the decimal coins by a decimal. It panics if d is zero.
+//
+// CONTRACT: No zero coins will be returned.
 func (coins DecCoins) QuoDec(d Dec) DecCoins {
-	res := make([]DecCoin, len(coins))
-	for i, coin := range coins {
+	if d.IsZero() {
+		panic("invalid zero decimal")
+	}
+
+	var res DecCoins
+	for _, coin := range coins {
 		quotient := DecCoin{
 			Denom:  coin.Denom,
 			Amount: coin.Amount.Quo(d),
 		}
-		res[i] = quotient
+
+		if !quotient.IsZero() {
+			res = res.Add(DecCoins{quotient})
+		}
 	}
+
 	return res
 }
 
-// divide all the coins by a decimal, truncating
+// QuoDecTruncate divides all the decimal coins by a decimal, truncating. It
+// panics if d is zero.
+//
+// CONTRACT: No zero coins will be returned.
 func (coins DecCoins) QuoDecTruncate(d Dec) DecCoins {
-	res := make([]DecCoin, len(coins))
-	for i, coin := range coins {
+	if d.IsZero() {
+		panic("invalid zero decimal")
+	}
+
+	var res DecCoins
+	for _, coin := range coins {
 		quotient := DecCoin{
 			Denom:  coin.Denom,
 			Amount: coin.Amount.QuoTruncate(d),
 		}
-		res[i] = quotient
+
+		if !quotient.IsZero() {
+			res = res.Add(DecCoins{quotient})
+		}
 	}
+
 	return res
 }
 
@@ -542,21 +579,21 @@ func ParseDecCoin(coinStr string) (coin DecCoin, err error) {
 // ParseDecCoins will parse out a list of decimal coins separated by commas.
 // If nothing is provided, it returns nil DecCoins. Returned decimal coins are
 // sorted.
-func ParseDecCoins(coinsStr string) (coins DecCoins, err error) {
+func ParseDecCoins(coinsStr string) (DecCoins, error) {
 	coinsStr = strings.TrimSpace(coinsStr)
 	if len(coinsStr) == 0 {
 		return nil, nil
 	}
 
-	splitRe := regexp.MustCompile(",|;")
-	coinStrs := splitRe.Split(coinsStr, -1)
-	for _, coinStr := range coinStrs {
+	coinStrs := strings.Split(coinsStr, ",")
+	coins := make(DecCoins, len(coinStrs))
+	for i, coinStr := range coinStrs {
 		coin, err := ParseDecCoin(coinStr)
 		if err != nil {
 			return nil, err
 		}
 
-		coins = append(coins, coin)
+		coins[i] = coin
 	}
 
 	// sort coins for determinism
diff --git a/types/dec_coin_test.go b/types/dec_coin_test.go
index b7b6f4d0c..7e904fe5d 100644
--- a/types/dec_coin_test.go
+++ b/types/dec_coin_test.go
@@ -253,6 +253,65 @@ func TestDecCoinsIntersect(t *testing.T) {
 		require.NoError(t, err, "unexpected parse error in %v", i)
 
 		require.True(t, in1.Intersect(in2).IsEqual(exr), "in1.cap(in2) != exr in %v", i)
-		// require.Equal(t, tc.expectedResult, in1.Intersect(in2).String(), "in1.cap(in2) != exr in %v", i)
+	}
+}
+
+func TestDecCoinsTruncateDecimal(t *testing.T) {
+	decCoinA := NewDecCoinFromDec("bar", MustNewDecFromStr("5.41"))
+	decCoinB := NewDecCoinFromDec("foo", MustNewDecFromStr("6.00"))
+
+	testCases := []struct {
+		input          DecCoins
+		truncatedCoins Coins
+		changeCoins    DecCoins
+	}{
+		{DecCoins{}, Coins(nil), DecCoins(nil)},
+		{
+			DecCoins{decCoinA, decCoinB},
+			Coins{NewInt64Coin(decCoinA.Denom, 5), NewInt64Coin(decCoinB.Denom, 6)},
+			DecCoins{NewDecCoinFromDec(decCoinA.Denom, MustNewDecFromStr("0.41"))},
+		},
+		{
+			DecCoins{decCoinB},
+			Coins{NewInt64Coin(decCoinB.Denom, 6)},
+			DecCoins(nil),
+		},
+	}
+
+	for i, tc := range testCases {
+		truncatedCoins, changeCoins := tc.input.TruncateDecimal()
+		require.Equal(
+			t, tc.truncatedCoins, truncatedCoins,
+			"unexpected truncated coins; tc #%d, input: %s", i, tc.input,
+		)
+		require.Equal(
+			t, tc.changeCoins, changeCoins,
+			"unexpected change coins; tc #%d, input: %s", i, tc.input,
+		)
+	}
+}
+
+func TestDecCoinsQuoDecTruncate(t *testing.T) {
+	x := MustNewDecFromStr("1.00")
+	y := MustNewDecFromStr("10000000000000000000.00")
+
+	testCases := []struct {
+		coins  DecCoins
+		input  Dec
+		result DecCoins
+		panics bool
+	}{
+		{DecCoins{}, ZeroDec(), DecCoins(nil), true},
+		{DecCoins{NewDecCoinFromDec("foo", x)}, y, DecCoins(nil), false},
+		{DecCoins{NewInt64DecCoin("foo", 5)}, NewDec(2), DecCoins{NewDecCoinFromDec("foo", MustNewDecFromStr("2.5"))}, false},
+	}
+
+	for i, tc := range testCases {
+		if tc.panics {
+			require.Panics(t, func() { tc.coins.QuoDecTruncate(tc.input) })
+		} else {
+			res := tc.coins.QuoDecTruncate(tc.input)
+			require.Equal(t, tc.result, res, "unexpected result; tc #%d, coins: %s, input: %s", i, tc.coins, tc.input)
+		}
 	}
 }
diff --git a/types/decimal.go b/types/decimal.go
index bec27468c..8fdad0ce0 100644
--- a/types/decimal.go
+++ b/types/decimal.go
@@ -332,6 +332,10 @@ func (d Dec) Format(s fmt.State, verb rune) {
 }
 
 func (d Dec) String() string {
+	if d.Int == nil {
+		return d.Int.String()
+	}
+
 	isNeg := d.IsNegative()
 	if d.IsNegative() {
 		d = d.Neg()
@@ -348,7 +352,6 @@ func (d Dec) String() string {
 	// TODO: Remove trailing zeros
 	// case 1, purely decimal
 	if inputSize <= Precision {
-
 		bzStr = make([]byte, Precision+2)
 
 		// 0. prefix
@@ -377,6 +380,7 @@ func (d Dec) String() string {
 	if isNeg {
 		return "-" + string(bzStr)
 	}
+
 	return string(bzStr)
 }
 
diff --git a/types/denom.go b/types/denom.go
new file mode 100644
index 000000000..73d396644
--- /dev/null
+++ b/types/denom.go
@@ -0,0 +1,64 @@
+package types
+
+import (
+	"fmt"
+)
+
+// denomUnits contains a mapping of denomination mapped to their respective unit
+// multipliers (e.g. 1atom = 10^-6uatom).
+var denomUnits = map[string]Dec{}
+
+// RegisterDenom registers a denomination with a corresponding unit. If the
+// denomination is already registered, an error will be returned.
+func RegisterDenom(denom string, unit Dec) error {
+	if err := validateDenom(denom); err != nil {
+		return err
+	}
+
+	if _, ok := denomUnits[denom]; ok {
+		return fmt.Errorf("denom %s already registered", denom)
+	}
+
+	denomUnits[denom] = unit
+	return nil
+}
+
+// GetDenomUnit returns a unit for a given denomination if it exists. A boolean
+// is returned if the denomination is registered.
+func GetDenomUnit(denom string) (Dec, bool) {
+	if err := validateDenom(denom); err != nil {
+		return ZeroDec(), false
+	}
+
+	unit, ok := denomUnits[denom]
+	if !ok {
+		return ZeroDec(), false
+	}
+
+	return unit, true
+}
+
+// ConvertCoin attempts to convert a coin to a given denomination. If the given
+// denomination is invalid or if neither denomination is registered, an error
+// is returned.
+func ConvertCoin(coin Coin, denom string) (Coin, error) {
+	if err := validateDenom(denom); err != nil {
+		return Coin{}, err
+	}
+
+	srcUnit, ok := GetDenomUnit(coin.Denom)
+	if !ok {
+		return Coin{}, fmt.Errorf("source denom not registered: %s", coin.Denom)
+	}
+
+	dstUnit, ok := GetDenomUnit(denom)
+	if !ok {
+		return Coin{}, fmt.Errorf("destination denom not registered: %s", denom)
+	}
+
+	if srcUnit.Equal(dstUnit) {
+		return NewCoin(denom, coin.Amount), nil
+	}
+
+	return NewCoin(denom, coin.Amount.ToDec().Mul(srcUnit.Quo(dstUnit)).TruncateInt()), nil
+}
diff --git a/types/denom_test.go b/types/denom_test.go
new file mode 100644
index 000000000..de6437994
--- /dev/null
+++ b/types/denom_test.go
@@ -0,0 +1,83 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	atom  = "atom"  // 1 (base denom unit)
+	matom = "matom" // 10^-3 (milli)
+	uatom = "uatom" // 10^-6 (micro)
+	natom = "natom" // 10^-9 (nano)
+)
+
+func TestRegisterDenom(t *testing.T) {
+	atomUnit := OneDec() // 1 (base denom unit)
+
+	require.NoError(t, RegisterDenom(atom, atomUnit))
+	require.Error(t, RegisterDenom(atom, atomUnit))
+
+	res, ok := GetDenomUnit(atom)
+	require.True(t, ok)
+	require.Equal(t, atomUnit, res)
+
+	res, ok = GetDenomUnit(matom)
+	require.False(t, ok)
+	require.Equal(t, ZeroDec(), res)
+
+	// reset registration
+	denomUnits = map[string]Dec{}
+}
+
+func TestConvertCoins(t *testing.T) {
+	atomUnit := OneDec() // 1 (base denom unit)
+	require.NoError(t, RegisterDenom(atom, atomUnit))
+
+	matomUnit := NewDecWithPrec(1, 3) // 10^-3 (milli)
+	require.NoError(t, RegisterDenom(matom, matomUnit))
+
+	uatomUnit := NewDecWithPrec(1, 6) // 10^-6 (micro)
+	require.NoError(t, RegisterDenom(uatom, uatomUnit))
+
+	natomUnit := NewDecWithPrec(1, 9) // 10^-9 (nano)
+	require.NoError(t, RegisterDenom(natom, natomUnit))
+
+	testCases := []struct {
+		input  Coin
+		denom  string
+		result Coin
+		expErr bool
+	}{
+		{NewCoin("foo", ZeroInt()), atom, Coin{}, true},
+		{NewCoin(atom, ZeroInt()), "foo", Coin{}, true},
+		{NewCoin(atom, ZeroInt()), "FOO", Coin{}, true},
+
+		{NewCoin(atom, NewInt(5)), matom, NewCoin(matom, NewInt(5000)), false},       // atom => matom
+		{NewCoin(atom, NewInt(5)), uatom, NewCoin(uatom, NewInt(5000000)), false},    // atom => uatom
+		{NewCoin(atom, NewInt(5)), natom, NewCoin(natom, NewInt(5000000000)), false}, // atom => natom
+
+		{NewCoin(uatom, NewInt(5000000)), matom, NewCoin(matom, NewInt(5000)), false},       // uatom => matom
+		{NewCoin(uatom, NewInt(5000000)), natom, NewCoin(natom, NewInt(5000000000)), false}, // uatom => natom
+		{NewCoin(uatom, NewInt(5000000)), atom, NewCoin(atom, NewInt(5)), false},            // uatom => atom
+
+		{NewCoin(matom, NewInt(5000)), natom, NewCoin(natom, NewInt(5000000000)), false}, // matom => natom
+		{NewCoin(matom, NewInt(5000)), uatom, NewCoin(uatom, NewInt(5000000)), false},    // matom => uatom
+	}
+
+	for i, tc := range testCases {
+		res, err := ConvertCoin(tc.input, tc.denom)
+		require.Equal(
+			t, tc.expErr, err != nil,
+			"unexpected error; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
+		)
+		require.Equal(
+			t, tc.result, res,
+			"invalid result; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
+		)
+	}
+
+	// reset registration
+	denomUnits = map[string]Dec{}
+}
diff --git a/types/rest/rest.go b/types/rest/rest.go
index d24e8e3d7..20fcef3fc 100644
--- a/types/rest/rest.go
+++ b/types/rest/rest.go
@@ -3,9 +3,12 @@
 package rest
 
 import (
+	"errors"
 	"fmt"
+	"github.com/tendermint/tendermint/types"
 	"io/ioutil"
 	"net/http"
+	"net/url"
 	"strconv"
 	"strings"
 
@@ -13,6 +16,11 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+const (
+	DefaultPage  = 1
+	DefaultLimit = 30 // should be consistent with tendermint/tendermint/rpc/core/pipe.go:19
+)
+
 // GasEstimateResponse defines a response definition for tx gas estimation.
 type GasEstimateResponse struct {
 	GasEstimate uint64 `json:"gas_estimate"`
@@ -211,3 +219,53 @@ func PostProcessResponse(w http.ResponseWriter, cdc *codec.Codec, response inter
 	w.Header().Set("Content-Type", "application/json")
 	_, _ = w.Write(output)
 }
+
+// ParseHTTPArgs parses the request's URL and returns a slice containing all arguments pairs.
+// It separates page and limit used for pagination
+func ParseHTTPArgs(r *http.Request) (tags []string, page, limit int, err error) {
+	tags = make([]string, 0, len(r.Form))
+	for key, values := range r.Form {
+		if key == "page" || key == "limit" {
+			continue
+		}
+		var value string
+		value, err = url.QueryUnescape(values[0])
+		if err != nil {
+			return tags, page, limit, err
+		}
+
+		var tag string
+		if key == types.TxHeightKey {
+			tag = fmt.Sprintf("%s=%s", key, value)
+		} else {
+			tag = fmt.Sprintf("%s='%s'", key, value)
+		}
+		tags = append(tags, tag)
+	}
+
+	pageStr := r.FormValue("page")
+	if pageStr == "" {
+		page = DefaultPage
+	} else {
+		page, err = strconv.Atoi(pageStr)
+		if err != nil {
+			return tags, page, limit, err
+		} else if page <= 0 {
+			return tags, page, limit, errors.New("page must greater than 0")
+		}
+	}
+
+	limitStr := r.FormValue("limit")
+	if limitStr == "" {
+		limit = DefaultLimit
+	} else {
+		limit, err = strconv.Atoi(limitStr)
+		if err != nil {
+			return tags, page, limit, err
+		} else if limit <= 0 {
+			return tags, page, limit, errors.New("limit must greater than 0")
+		}
+	}
+
+	return tags, page, limit, nil
+}
diff --git a/types/rest/rest_test.go b/types/rest/rest_test.go
index 876cffe68..e0acbd5b4 100644
--- a/types/rest/rest_test.go
+++ b/types/rest/rest_test.go
@@ -3,6 +3,7 @@
 package rest
 
 import (
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -55,3 +56,55 @@ func TestBaseReqValidateBasic(t *testing.T) {
 		})
 	}
 }
+
+func TestParseHTTPArgs(t *testing.T) {
+	req0 := mustNewRequest(t, "", "/", nil)
+	req1 := mustNewRequest(t, "", "/?limit=5", nil)
+	req2 := mustNewRequest(t, "", "/?page=5", nil)
+	req3 := mustNewRequest(t, "", "/?page=5&limit=5", nil)
+
+	reqE1 := mustNewRequest(t, "", "/?page=-1", nil)
+	reqE2 := mustNewRequest(t, "", "/?limit=-1", nil)
+	req4 := mustNewRequest(t, "", "/?foo=faa", nil)
+
+	tests := []struct {
+		name  string
+		req   *http.Request
+		w     http.ResponseWriter
+		tags  []string
+		page  int
+		limit int
+		err   bool
+	}{
+		{"no params", req0, httptest.NewRecorder(), []string{}, DefaultPage, DefaultLimit, false},
+		{"Limit", req1, httptest.NewRecorder(), []string{}, DefaultPage, 5, false},
+		{"Page", req2, httptest.NewRecorder(), []string{}, 5, DefaultLimit, false},
+		{"Page and limit", req3, httptest.NewRecorder(), []string{}, 5, 5, false},
+
+		{"error page 0", reqE1, httptest.NewRecorder(), []string{}, DefaultPage, DefaultLimit, true},
+		{"error limit 0", reqE2, httptest.NewRecorder(), []string{}, DefaultPage, DefaultLimit, true},
+
+		{"tags", req4, httptest.NewRecorder(), []string{"foo='faa'"}, DefaultPage, DefaultLimit, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tags, page, limit, err := ParseHTTPArgs(tt.req)
+			if tt.err {
+				require.NotNil(t, err)
+			} else {
+				require.Nil(t, err)
+				require.Equal(t, tt.tags, tags)
+				require.Equal(t, tt.page, page)
+				require.Equal(t, tt.limit, limit)
+			}
+		})
+	}
+}
+
+func mustNewRequest(t *testing.T, method, url string, body io.Reader) *http.Request {
+	req, err := http.NewRequest(method, url, body)
+	require.NoError(t, err)
+	err = req.ParseForm()
+	require.NoError(t, err)
+	return req
+}
diff --git a/types/result.go b/types/result.go
index 8ff873bfc..e83ed56e1 100644
--- a/types/result.go
+++ b/types/result.go
@@ -1,6 +1,7 @@
 package types
 
 import (
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"strings"
@@ -67,7 +68,8 @@ type TxResponse struct {
 	Height    int64           `json:"height"`
 	TxHash    string          `json:"txhash"`
 	Code      uint32          `json:"code,omitempty"`
-	Data      []byte          `json:"data,omitempty"`
+	Data      string          `json:"data,omitempty"`
+	RawLog    string          `json:"raw_log,omitempty"`
 	Logs      ABCIMessageLogs `json:"logs,omitempty"`
 	Info      string          `json:"info,omitempty"`
 	GasWanted int64           `json:"gas_wanted,omitempty"`
@@ -75,10 +77,11 @@ type TxResponse struct {
 	Tags      StringTags      `json:"tags,omitempty"`
 	Codespace string          `json:"codespace,omitempty"`
 	Tx        Tx              `json:"tx,omitempty"`
+	Timestamp string          `json:"timestamp,omitempty"`
 }
 
 // NewResponseResultTx returns a TxResponse given a ResultTx from tendermint
-func NewResponseResultTx(res *ctypes.ResultTx, tx Tx) TxResponse {
+func NewResponseResultTx(res *ctypes.ResultTx, tx Tx, timestamp string) TxResponse {
 	if res == nil {
 		return TxResponse{}
 	}
@@ -89,18 +92,56 @@ func NewResponseResultTx(res *ctypes.ResultTx, tx Tx) TxResponse {
 		TxHash:    res.Hash.String(),
 		Height:    res.Height,
 		Code:      res.TxResult.Code,
-		Data:      res.TxResult.Data,
+		Data:      strings.ToUpper(hex.EncodeToString(res.TxResult.Data)),
+		RawLog:    res.TxResult.Log,
 		Logs:      parsedLogs,
 		Info:      res.TxResult.Info,
 		GasWanted: res.TxResult.GasWanted,
 		GasUsed:   res.TxResult.GasUsed,
 		Tags:      TagsToStringTags(res.TxResult.Tags),
 		Tx:        tx,
+		Timestamp: timestamp,
 	}
 }
 
-// NewResponseFormatBroadcastTxCommit returns a TxResponse given a ResultBroadcastTxCommit from tendermint
+// NewResponseFormatBroadcastTxCommit returns a TxResponse given a
+// ResultBroadcastTxCommit from tendermint.
 func NewResponseFormatBroadcastTxCommit(res *ctypes.ResultBroadcastTxCommit) TxResponse {
+	if !res.CheckTx.IsOK() {
+		return newTxResponseCheckTx(res)
+	}
+
+	return newTxResponseDeliverTx(res)
+}
+
+func newTxResponseCheckTx(res *ctypes.ResultBroadcastTxCommit) TxResponse {
+	if res == nil {
+		return TxResponse{}
+	}
+
+	var txHash string
+	if res.Hash != nil {
+		txHash = res.Hash.String()
+	}
+
+	parsedLogs, _ := ParseABCILogs(res.CheckTx.Log)
+
+	return TxResponse{
+		Height:    res.Height,
+		TxHash:    txHash,
+		Code:      res.CheckTx.Code,
+		Data:      strings.ToUpper(hex.EncodeToString(res.CheckTx.Data)),
+		RawLog:    res.CheckTx.Log,
+		Logs:      parsedLogs,
+		Info:      res.CheckTx.Info,
+		GasWanted: res.CheckTx.GasWanted,
+		GasUsed:   res.CheckTx.GasUsed,
+		Tags:      TagsToStringTags(res.CheckTx.Tags),
+		Codespace: res.CheckTx.Codespace,
+	}
+}
+
+func newTxResponseDeliverTx(res *ctypes.ResultBroadcastTxCommit) TxResponse {
 	if res == nil {
 		return TxResponse{}
 	}
@@ -116,7 +157,8 @@ func NewResponseFormatBroadcastTxCommit(res *ctypes.ResultBroadcastTxCommit) TxR
 		Height:    res.Height,
 		TxHash:    txHash,
 		Code:      res.DeliverTx.Code,
-		Data:      res.DeliverTx.Data,
+		Data:      strings.ToUpper(hex.EncodeToString(res.DeliverTx.Data)),
+		RawLog:    res.DeliverTx.Log,
 		Logs:      parsedLogs,
 		Info:      res.DeliverTx.Info,
 		GasWanted: res.DeliverTx.GasWanted,
@@ -124,7 +166,6 @@ func NewResponseFormatBroadcastTxCommit(res *ctypes.ResultBroadcastTxCommit) TxR
 		Tags:      TagsToStringTags(res.DeliverTx.Tags),
 		Codespace: res.DeliverTx.Codespace,
 	}
-
 }
 
 // NewResponseFormatBroadcastTx returns a TxResponse given a ResultBroadcastTx from tendermint
@@ -137,7 +178,8 @@ func NewResponseFormatBroadcastTx(res *ctypes.ResultBroadcastTx) TxResponse {
 
 	return TxResponse{
 		Code:   res.Code,
-		Data:   res.Data.Bytes(),
+		Data:   res.Data.String(),
+		RawLog: res.Log,
 		Logs:   parsedLogs,
 		TxHash: res.Hash.String(),
 	}
@@ -159,8 +201,12 @@ func (r TxResponse) String() string {
 		sb.WriteString(fmt.Sprintf("  Code: %d\n", r.Code))
 	}
 
-	if r.Data != nil {
-		sb.WriteString(fmt.Sprintf("  Data: %s\n", string(r.Data)))
+	if r.Data != "" {
+		sb.WriteString(fmt.Sprintf("  Data: %s\n", r.Data))
+	}
+
+	if r.RawLog != "" {
+		sb.WriteString(fmt.Sprintf("  Raw Log: %s\n", r.RawLog))
 	}
 
 	if r.Logs != nil {
@@ -187,6 +233,10 @@ func (r TxResponse) String() string {
 		sb.WriteString(fmt.Sprintf("  Codespace: %s\n", r.Codespace))
 	}
 
+	if r.Timestamp != "" {
+		sb.WriteString(fmt.Sprintf("  Timestamp: %s\n", r.Timestamp))
+	}
+
 	return strings.TrimSpace(sb.String())
 }
 
diff --git a/types/staking.go b/types/staking.go
index 428979a18..79832ac00 100644
--- a/types/staking.go
+++ b/types/staking.go
@@ -61,20 +61,23 @@ func (b BondStatus) Equal(b2 BondStatus) bool {
 
 // validator for a delegated proof of stake system
 type Validator interface {
-	GetJailed() bool              // whether the validator is jailed
-	GetMoniker() string           // moniker of the validator
-	GetStatus() BondStatus        // status of the validator
-	GetOperator() ValAddress      // operator address to receive/return validators coins
-	GetConsPubKey() crypto.PubKey // validation consensus pubkey
-	GetConsAddr() ConsAddress     // validation consensus address
-	GetTokens() Int               // validation tokens
-	GetBondedTokens() Int         // validator bonded tokens
-	GetTendermintPower() int64    // validation power in tendermint
-	GetCommission() Dec           // validator commission rate
-	GetMinSelfDelegation() Int    // validator minimum self delegation
-	GetDelegatorShares() Dec      // total outstanding delegator shares
-	ShareTokens(Dec) Dec          // token worth of provided delegator shares
-	ShareTokensTruncated(Dec) Dec // token worth of provided delegator shares, truncated
+	IsJailed() bool                                 // whether the validator is jailed
+	GetMoniker() string                             // moniker of the validator
+	GetStatus() BondStatus                          // status of the validator
+	GetOperator() ValAddress                        // operator address to receive/return validators coins
+	GetConsPubKey() crypto.PubKey                   // validation consensus pubkey
+	GetConsAddr() ConsAddress                       // validation consensus address
+	GetTokens() Int                                 // validation tokens
+	GetBondedTokens() Int                           // validator bonded tokens
+	GetTendermintPower() int64                      // validation power in tendermint
+	GetCommission() Dec                             // validator commission rate
+	GetMinSelfDelegation() Int                      // validator minimum self delegation
+	GetDelegatorShares() Dec                        // total outstanding delegator shares
+	TokensFromShares(Dec) Dec                       // token worth of provided delegator shares
+	TokensFromSharesTruncated(Dec) Dec              // token worth of provided delegator shares, truncated
+	TokensFromSharesRoundUp(Dec) Dec                // token worth of provided delegator shares, rounded up
+	SharesFromTokens(amt Int) (Dec, Error)          // shares worth of delegator's bond
+	SharesFromTokensTruncated(amt Int) (Dec, Error) // truncated shares worth of delegator's bond
 }
 
 // validator which fulfills abci validator interface for use in Tendermint
diff --git a/vendor-deps b/vendor-deps
new file mode 100644
index 000000000..e69de29bb
diff --git a/x/auth/ante_test.go b/x/auth/ante_test.go
index 8d1db6f1a..beff481e9 100644
--- a/x/auth/ante_test.go
+++ b/x/auth/ante_test.go
@@ -300,18 +300,18 @@ func TestAnteHandlerFees(t *testing.T) {
 	tx = newTestTx(ctx, msgs, privs, accnums, seqs, fee)
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeInsufficientFunds)
 
-	acc1.SetCoins(sdk.Coins{sdk.NewInt64Coin("atom", 149)})
+	acc1.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("atom", 149)))
 	input.ak.SetAccount(ctx, acc1)
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeInsufficientFunds)
 
 	require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(emptyCoins))
 	require.True(t, input.ak.GetAccount(ctx, addr1).GetCoins().AmountOf("atom").Equal(sdk.NewInt(149)))
 
-	acc1.SetCoins(sdk.Coins{sdk.NewInt64Coin("atom", 150)})
+	acc1.SetCoins(sdk.NewCoins(sdk.NewInt64Coin("atom", 150)))
 	input.ak.SetAccount(ctx, acc1)
 	checkValidTx(t, anteHandler, ctx, tx, false)
 
-	require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(sdk.Coins{sdk.NewInt64Coin("atom", 150)}))
+	require.True(t, input.fck.GetCollectedFees(ctx).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("atom", 150))))
 	require.True(t, input.ak.GetAccount(ctx, addr1).GetCoins().AmountOf("atom").Equal(sdk.NewInt(0)))
 }
 
@@ -333,24 +333,24 @@ func TestAnteHandlerMemoGas(t *testing.T) {
 	var tx sdk.Tx
 	msg := newTestMsg(addr1)
 	privs, accnums, seqs := []crypto.PrivKey{priv1}, []uint64{0}, []uint64{0}
-	fee := NewStdFee(0, sdk.Coins{sdk.NewInt64Coin("atom", 0)})
+	fee := NewStdFee(0, sdk.NewCoins(sdk.NewInt64Coin("atom", 0)))
 
 	// tx does not have enough gas
 	tx = newTestTx(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee)
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeOutOfGas)
 
 	// tx with memo doesn't have enough gas
-	fee = NewStdFee(801, sdk.Coins{sdk.NewInt64Coin("atom", 0)})
+	fee = NewStdFee(801, sdk.NewCoins(sdk.NewInt64Coin("atom", 0)))
 	tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, "abcininasidniandsinasindiansdiansdinaisndiasndiadninsd")
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeOutOfGas)
 
 	// memo too large
-	fee = NewStdFee(9000, sdk.Coins{sdk.NewInt64Coin("atom", 0)})
+	fee = NewStdFee(9000, sdk.NewCoins(sdk.NewInt64Coin("atom", 0)))
 	tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, strings.Repeat("01234567890", 500))
 	checkInvalidTx(t, anteHandler, ctx, tx, false, sdk.CodeMemoTooLarge)
 
 	// tx with memo has enough gas
-	fee = NewStdFee(9000, sdk.Coins{sdk.NewInt64Coin("atom", 0)})
+	fee = NewStdFee(9000, sdk.NewCoins(sdk.NewInt64Coin("atom", 0)))
 	tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, strings.Repeat("0123456789", 10))
 	checkValidTx(t, anteHandler, ctx, tx, false)
 }
@@ -721,28 +721,28 @@ func TestEnsureSufficientMempoolFees(t *testing.T) {
 		input      StdFee
 		expectedOK bool
 	}{
-		{NewStdFee(200000, sdk.Coins{sdk.NewInt64Coin("photino", 5)}), false},
-		{NewStdFee(200000, sdk.Coins{sdk.NewInt64Coin("stake", 1)}), false},
-		{NewStdFee(200000, sdk.Coins{sdk.NewInt64Coin("stake", 2)}), true},
-		{NewStdFee(200000, sdk.Coins{sdk.NewInt64Coin("photino", 10)}), true},
+		{NewStdFee(200000, sdk.NewCoins(sdk.NewInt64Coin("photino", 5))), false},
+		{NewStdFee(200000, sdk.NewCoins(sdk.NewInt64Coin("stake", 1))), false},
+		{NewStdFee(200000, sdk.NewCoins(sdk.NewInt64Coin("stake", 2))), true},
+		{NewStdFee(200000, sdk.NewCoins(sdk.NewInt64Coin("photino", 10))), true},
 		{
 			NewStdFee(
 				200000,
-				sdk.Coins{
+				sdk.NewCoins(
 					sdk.NewInt64Coin("photino", 10),
 					sdk.NewInt64Coin("stake", 2),
-				},
+				),
 			),
 			true,
 		},
 		{
 			NewStdFee(
 				200000,
-				sdk.Coins{
+				sdk.NewCoins(
 					sdk.NewInt64Coin("atom", 5),
 					sdk.NewInt64Coin("photino", 10),
 					sdk.NewInt64Coin("stake", 2),
-				},
+				),
 			),
 			true,
 		},
diff --git a/x/auth/client/cli/multisign.go b/x/auth/client/cli/multisign.go
index d25983a12..ec9613554 100644
--- a/x/auth/client/cli/multisign.go
+++ b/x/auth/client/cli/multisign.go
@@ -105,7 +105,9 @@ func makeMultiSignCmd(cdc *amino.Codec) func(cmd *cobra.Command, args []string)
 			if ok := stdSig.PubKey.VerifyBytes(sigBytes, stdSig.Signature); !ok {
 				return fmt.Errorf("couldn't verify signature")
 			}
-			multisigSig.AddSignatureFromPubKey(stdSig.Signature, stdSig.PubKey, multisigPub.PubKeys)
+			if err := multisigSig.AddSignatureFromPubKey(stdSig.Signature, stdSig.PubKey, multisigPub.PubKeys); err != nil {
+				return err
+			}
 		}
 
 		newStdSig := auth.StdSignature{Signature: cdc.MustMarshalBinaryBare(multisigSig), PubKey: multisigPub}
diff --git a/x/auth/client/cli/sign.go b/x/auth/client/cli/sign.go
index e30fd2e4f..6d3a9fe29 100644
--- a/x/auth/client/cli/sign.go
+++ b/x/auth/client/cli/sign.go
@@ -27,33 +27,35 @@ const (
 	flagOutfile      = "output-document"
 )
 
-// GetSignCommand returns the sign command
+// GetSignCommand returns the transaction sign command.
 func GetSignCommand(codec *amino.Codec) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "sign [file]",
 		Short: "Sign transactions generated offline",
 		Long: `Sign transactions created with the --generate-only flag.
-Read a transaction from [file], sign it, and print its JSON encoding.
+It will read a transaction from [file], sign it, and print its JSON encoding.
 
-If the flag --signature-only flag is on, it outputs a JSON representation
+If the flag --signature-only flag is set, it will output a JSON representation
 of the generated signature only.
 
-If the flag --validate-signatures is on, then the command would check whether all required
+If the flag --validate-signatures is set, then the command would check whether all required
 signers have signed the transactions, whether the signatures were collected in the right
 order, and if the signature is valid over the given transaction. If the --offline
-flag is also provided, signature validation over the transaction will be not be
-performed as that will require communication with a full node.
+flag is also set, signature validation over the transaction will be not be
+performed as that will require RPC communication with a full node.
 
-The --offline flag makes sure that the client will not reach out to an external node.
-Thus account number or sequence number lookups will not be performed and it is
-recommended to set such parameters manually.
+The --offline flag makes sure that the client will not reach out to full node.
+As a result, the account and sequence number queries will not be performed and
+it is required to set such parameters manually. Note, invalid values will cause
+the transaction to fail.
 
 The --multisig=<multisig_key> flag generates a signature on behalf of a multisig account
 key. It implies --signature-only. Full multisig signed transactions may eventually
 be generated via the 'multisign' command.
 `,
-		RunE: makeSignCmd(codec),
-		Args: cobra.ExactArgs(1),
+		PreRun: preSignCmd,
+		RunE:   makeSignCmd(codec),
+		Args:   cobra.ExactArgs(1),
 	}
 
 	cmd.Flags().String(
@@ -69,11 +71,22 @@ be generated via the 'multisign' command.
 		"Print the addresses that must sign the transaction, those who have already signed it, and make sure that signatures are in the correct order",
 	)
 	cmd.Flags().Bool(flagSigOnly, false, "Print only the generated signature, then exit")
-	cmd.Flags().Bool(flagOffline, false, "Offline mode. Do not query a full node")
+	cmd.Flags().Bool(flagOffline, false, "Offline mode; Do not query a full node")
 	cmd.Flags().String(flagOutfile, "", "The document will be written to the given file instead of STDOUT")
 
-	// add the flags here and return the command
-	return client.PostCommands(cmd)[0]
+	cmd = client.PostCommands(cmd)[0]
+	cmd.MarkFlagRequired(client.FlagFrom)
+
+	return cmd
+}
+
+func preSignCmd(cmd *cobra.Command, _ []string) {
+	// Conditionally mark the account and sequence numbers required as no RPC
+	// query will be done.
+	if viper.GetBool(flagOffline) {
+		cmd.MarkFlagRequired(client.FlagAccountNumber)
+		cmd.MarkFlagRequired(client.FlagSequence)
+	}
 }
 
 func makeSignCmd(cdc *amino.Codec) func(cmd *cobra.Command, args []string) error {
@@ -95,11 +108,6 @@ func makeSignCmd(cdc *amino.Codec) func(cmd *cobra.Command, args []string) error
 			return nil
 		}
 
-		from := viper.GetString(client.FlagFrom)
-		if from == "" {
-			return fmt.Errorf("required flag '%s' has not been set", client.FlagFrom)
-		}
-
 		// if --signature-only is on, then override --append
 		var newTx auth.StdTx
 		generateSignatureOnly := viper.GetBool(flagSigOnly)
diff --git a/x/auth/client/txbuilder/txbuilder.go b/x/auth/client/txbuilder/txbuilder.go
index 3ea6989e6..480d8fd41 100644
--- a/x/auth/client/txbuilder/txbuilder.go
+++ b/x/auth/client/txbuilder/txbuilder.go
@@ -245,7 +245,7 @@ func (bldr TxBuilder) BuildTxForSim(msgs []sdk.Msg) ([]byte, error) {
 	return bldr.txEncoder(auth.NewStdTx(signMsg.Msgs, signMsg.Fee, sigs, signMsg.Memo))
 }
 
-// SignStdTx appends a signature to a StdTx and returns a copy of a it. If append
+// SignStdTx appends a signature to a StdTx and returns a copy of it. If append
 // is false, it replaces the signatures already attached with the new signature.
 func (bldr TxBuilder) SignStdTx(name, passphrase string, stdTx auth.StdTx, appendSig bool) (signedStdTx auth.StdTx, err error) {
 	stdSignature, err := MakeSignature(bldr.keybase, name, passphrase, StdSignMsg{
diff --git a/x/auth/feekeeper.go b/x/auth/feekeeper.go
index aa8cf9212..bc6506b17 100644
--- a/x/auth/feekeeper.go
+++ b/x/auth/feekeeper.go
@@ -33,10 +33,11 @@ func (fck FeeCollectionKeeper) GetCollectedFees(ctx sdk.Context) sdk.Coins {
 	store := ctx.KVStore(fck.key)
 	bz := store.Get(collectedFeesKey)
 	if bz == nil {
-		return sdk.Coins{}
+		return sdk.NewCoins()
 	}
 
-	feePool := &(sdk.Coins{})
+	emptyFees := sdk.NewCoins()
+	feePool := &emptyFees
 	fck.cdc.MustUnmarshalBinaryLengthPrefixed(bz, feePool)
 	return *feePool
 }
@@ -57,5 +58,5 @@ func (fck FeeCollectionKeeper) AddCollectedFees(ctx sdk.Context, coins sdk.Coins
 
 // ClearCollectedFees - clear the fee pool
 func (fck FeeCollectionKeeper) ClearCollectedFees(ctx sdk.Context) {
-	fck.setCollectedFees(ctx, sdk.Coins{})
+	fck.setCollectedFees(ctx, sdk.NewCoins())
 }
diff --git a/x/auth/feekeeper_test.go b/x/auth/feekeeper_test.go
index a624fb38c..ab49305f1 100644
--- a/x/auth/feekeeper_test.go
+++ b/x/auth/feekeeper_test.go
@@ -9,9 +9,9 @@ import (
 )
 
 var (
-	emptyCoins = sdk.Coins{}
-	oneCoin    = sdk.Coins{sdk.NewInt64Coin("foocoin", 1)}
-	twoCoins   = sdk.Coins{sdk.NewInt64Coin("foocoin", 2)}
+	emptyCoins = sdk.NewCoins()
+	oneCoin    = sdk.NewCoins(sdk.NewInt64Coin("foocoin", 1))
+	twoCoins   = sdk.NewCoins(sdk.NewInt64Coin("foocoin", 2))
 )
 
 func TestFeeCollectionKeeperGetSet(t *testing.T) {
diff --git a/x/auth/genesis.go b/x/auth/genesis.go
index da2beb0d7..7f94415df 100644
--- a/x/auth/genesis.go
+++ b/x/auth/genesis.go
@@ -22,7 +22,7 @@ func NewGenesisState(collectedFees sdk.Coins, params Params) GenesisState {
 
 // DefaultGenesisState - Return a default genesis state
 func DefaultGenesisState() GenesisState {
-	return NewGenesisState(sdk.Coins{}, DefaultParams())
+	return NewGenesisState(sdk.NewCoins(), DefaultParams())
 }
 
 // InitGenesis - Init store state from genesis data
diff --git a/x/auth/simulation/fake.go b/x/auth/simulation/fake.go
index f28c27cd9..7849bd807 100644
--- a/x/auth/simulation/fake.go
+++ b/x/auth/simulation/fake.go
@@ -2,29 +2,28 @@ package simulation
 
 import (
 	"errors"
-	"fmt"
 	"math/big"
 	"math/rand"
 
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
-	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
 )
 
 // SimulateDeductFee
 func SimulateDeductFee(m auth.AccountKeeper, f auth.FeeCollectionKeeper) simulation.Operation {
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (
+		opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		account := simulation.RandomAcc(r, accs)
 		stored := m.GetAccount(ctx, account.Address)
 		initCoins := stored.GetCoins()
+		opMsg = simulation.NewOperationMsgBasic("auth", "deduct_fee", "", false, nil)
 
 		if len(initCoins) == 0 {
-			event(fmt.Sprintf("auth/SimulateDeductFee/false"))
-			return action, nil, nil
+			return opMsg, nil, nil
 		}
 
 		denomIndex := r.Intn(len(initCoins))
@@ -32,8 +31,7 @@ func SimulateDeductFee(m auth.AccountKeeper, f auth.FeeCollectionKeeper) simulat
 
 		amt, err := randPositiveInt(r, randCoin.Amount)
 		if err != nil {
-			event(fmt.Sprintf("auth/SimulateDeductFee/false"))
-			return action, nil, nil
+			return opMsg, nil, nil
 		}
 
 		// Create a random fee and verify the fees are within the account's spendable
@@ -41,15 +39,13 @@ func SimulateDeductFee(m auth.AccountKeeper, f auth.FeeCollectionKeeper) simulat
 		fees := sdk.Coins{sdk.NewCoin(randCoin.Denom, amt)}
 		spendableCoins := stored.SpendableCoins(ctx.BlockHeader().Time)
 		if _, hasNeg := spendableCoins.SafeSub(fees); hasNeg {
-			event(fmt.Sprintf("auth/SimulateDeductFee/false"))
-			return action, nil, nil
+			return opMsg, nil, nil
 		}
 
 		// get the new account balance
 		newCoins, hasNeg := initCoins.SafeSub(fees)
 		if hasNeg {
-			event(fmt.Sprintf("auth/SimulateDeductFee/false"))
-			return action, nil, nil
+			return opMsg, nil, nil
 		}
 
 		if err := stored.SetCoins(newCoins); err != nil {
@@ -58,10 +54,9 @@ func SimulateDeductFee(m auth.AccountKeeper, f auth.FeeCollectionKeeper) simulat
 
 		m.SetAccount(ctx, stored)
 		f.AddCollectedFees(ctx, fees)
-		event(fmt.Sprintf("auth/SimulateDeductFee/true"))
 
-		action = "TestDeductFee"
-		return action, nil, nil
+		opMsg.OK = true
+		return opMsg, nil, nil
 	}
 }
 
diff --git a/x/auth/stdtx.go b/x/auth/stdtx.go
index 4ca318635..5f11a2f3e 100644
--- a/x/auth/stdtx.go
+++ b/x/auth/stdtx.go
@@ -141,7 +141,7 @@ func (fee StdFee) Bytes() []byte {
 	// (in the lcd_test, client side its null,
 	// server side its [])
 	if len(fee.Amount) == 0 {
-		fee.Amount = sdk.Coins{}
+		fee.Amount = sdk.NewCoins()
 	}
 	bz, err := msgCdc.MarshalJSON(fee) // TODO
 	if err != nil {
@@ -150,6 +150,15 @@ func (fee StdFee) Bytes() []byte {
 	return bz
 }
 
+// GasPrices returns the gas prices for a StdFee.
+//
+// NOTE: The gas prices returned are not the true gas prices that were
+// originally part of the submitted transaction because the fee is computed
+// as fee = ceil(gasWanted * gasPrices).
+func (fee StdFee) GasPrices() sdk.DecCoins {
+	return sdk.NewDecCoins(fee.Amount).QuoDec(sdk.NewDec(int64(fee.Gas)))
+}
+
 //__________________________________________________________
 
 // StdSignDoc is replay-prevention structure.
diff --git a/x/auth/test_utils.go b/x/auth/test_utils.go
index 800622b42..d6533d168 100644
--- a/x/auth/test_utils.go
+++ b/x/auth/test_utils.go
@@ -55,7 +55,7 @@ func newTestMsg(addrs ...sdk.AccAddress) *sdk.TestMsg {
 
 func newStdFee() StdFee {
 	return NewStdFee(50000,
-		sdk.Coins{sdk.NewInt64Coin("atom", 150)},
+		sdk.NewCoins(sdk.NewInt64Coin("atom", 150)),
 	)
 }
 
diff --git a/x/bank/app_test.go b/x/bank/app_test.go
index 8703d71ec..951a17469 100644
--- a/x/bank/app_test.go
+++ b/x/bank/app_test.go
@@ -123,7 +123,8 @@ func TestSendNotEnoughBalance(t *testing.T) {
 	origSeq := res1.GetSequence()
 
 	sendMsg := NewMsgSend(addr1, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 100)})
-	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, []sdk.Msg{sendMsg}, []uint64{origAccNum}, []uint64{origSeq}, false, false, priv1)
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{sendMsg}, []uint64{origAccNum}, []uint64{origSeq}, false, false, priv1)
 
 	mock.CheckBalance(t, mapp, addr1, sdk.Coins{sdk.NewInt64Coin("foocoin", 67)})
 
@@ -173,7 +174,8 @@ func TestMsgMultiSendWithAccounts(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
+		header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+		mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
 
 		for _, eb := range tc.expectedBalances {
 			mock.CheckBalance(t, mapp, eb.addr, eb.coins)
@@ -212,7 +214,8 @@ func TestMsgMultiSendMultipleOut(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
+		header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+		mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
 
 		for _, eb := range tc.expectedBalances {
 			mock.CheckBalance(t, mapp, eb.addr, eb.coins)
@@ -241,7 +244,7 @@ func TestMsgMultiSendMultipleInOut(t *testing.T) {
 	testCases := []appTestCase{
 		{
 			msgs:       []sdk.Msg{multiSendMsg3},
-			accNums:    []uint64{0, 0},
+			accNums:    []uint64{0, 2},
 			accSeqs:    []uint64{0, 0},
 			expSimPass: true,
 			expPass:    true,
@@ -256,7 +259,8 @@ func TestMsgMultiSendMultipleInOut(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
+		header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+		mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
 
 		for _, eb := range tc.expectedBalances {
 			mock.CheckBalance(t, mapp, eb.addr, eb.coins)
@@ -289,7 +293,7 @@ func TestMsgMultiSendDependent(t *testing.T) {
 		},
 		{
 			msgs:       []sdk.Msg{multiSendMsg4},
-			accNums:    []uint64{0},
+			accNums:    []uint64{1},
 			accSeqs:    []uint64{0},
 			expSimPass: true,
 			expPass:    true,
@@ -301,7 +305,8 @@ func TestMsgMultiSendDependent(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
+		header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+		mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, tc.msgs, tc.accNums, tc.accSeqs, tc.expSimPass, tc.expPass, tc.privKeys...)
 
 		for _, eb := range tc.expectedBalances {
 			mock.CheckBalance(t, mapp, eb.addr, eb.coins)
diff --git a/x/bank/client/cli/sendtx.go b/x/bank/client/cli/sendtx.go
index 7e8a29a92..2f1d45b95 100644
--- a/x/bank/client/cli/sendtx.go
+++ b/x/bank/client/cli/sendtx.go
@@ -62,5 +62,9 @@ func SendTxCmd(cdc *codec.Codec) *cobra.Command {
 			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}, false)
 		},
 	}
-	return client.PostCommands(cmd)[0]
+
+	cmd = client.PostCommands(cmd)[0]
+	cmd.MarkFlagRequired(client.FlagFrom)
+
+	return cmd
 }
diff --git a/x/bank/expected_keepers.go b/x/bank/expected_keepers.go
new file mode 100644
index 000000000..6d256d926
--- /dev/null
+++ b/x/bank/expected_keepers.go
@@ -0,0 +1,10 @@
+package bank
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// expected crisis keeper
+type CrisisKeeper interface {
+	RegisterRoute(moduleName, route string, invar sdk.Invariant)
+}
diff --git a/x/bank/simulation/invariants.go b/x/bank/invariants.go
similarity index 83%
rename from x/bank/simulation/invariants.go
rename to x/bank/invariants.go
index 7448b4687..4ca4c3d9a 100644
--- a/x/bank/simulation/invariants.go
+++ b/x/bank/invariants.go
@@ -1,4 +1,4 @@
-package simulation
+package bank
 
 import (
 	"errors"
@@ -8,6 +8,12 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth"
 )
 
+// register bank invariants
+func RegisterInvariants(c CrisisKeeper, ak auth.AccountKeeper) {
+	c.RegisterRoute("bank", "nonnegative-outstanding",
+		NonnegativeBalanceInvariant(ak))
+}
+
 // NonnegativeBalanceInvariant checks that all accounts in the application have non-negative balances
 func NonnegativeBalanceInvariant(ak auth.AccountKeeper) sdk.Invariant {
 	return func(ctx sdk.Context) error {
@@ -28,7 +34,7 @@ func NonnegativeBalanceInvariant(ak auth.AccountKeeper) sdk.Invariant {
 // is what is expected
 func TotalCoinsInvariant(ak auth.AccountKeeper, totalSupplyFn func() sdk.Coins) sdk.Invariant {
 	return func(ctx sdk.Context) error {
-		totalCoins := sdk.Coins{}
+		totalCoins := sdk.NewCoins()
 
 		chkAccount := func(acc auth.Account) bool {
 			coins := acc.GetCoins()
diff --git a/x/bank/keeper.go b/x/bank/keeper.go
index 81db06387..c5322ec5c 100644
--- a/x/bank/keeper.go
+++ b/x/bank/keeper.go
@@ -211,7 +211,7 @@ func (keeper BaseViewKeeper) Codespace() sdk.CodespaceType {
 func getCoins(ctx sdk.Context, am auth.AccountKeeper, addr sdk.AccAddress) sdk.Coins {
 	acc := am.GetAccount(ctx, addr)
 	if acc == nil {
-		return sdk.Coins{}
+		return sdk.NewCoins()
 	}
 	return acc.GetCoins()
 }
@@ -255,7 +255,7 @@ func subtractCoins(ctx sdk.Context, ak auth.AccountKeeper, addr sdk.AccAddress,
 		return nil, nil, sdk.ErrInvalidCoins(amt.String())
 	}
 
-	oldCoins, spendableCoins := sdk.Coins{}, sdk.Coins{}
+	oldCoins, spendableCoins := sdk.NewCoins(), sdk.NewCoins()
 
 	acc := getAccount(ctx, ak, addr)
 	if acc != nil {
diff --git a/x/bank/keeper_test.go b/x/bank/keeper_test.go
index cb277882e..ee8e7e655 100644
--- a/x/bank/keeper_test.go
+++ b/x/bank/keeper_test.go
@@ -66,71 +66,71 @@ func TestKeeper(t *testing.T) {
 
 	// Test GetCoins/SetCoins
 	input.ak.SetAccount(ctx, acc)
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins()))
 
-	bankKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
+	bankKeeper.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
 
 	// Test HasCoins
-	require.True(t, bankKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
-	require.True(t, bankKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
-	require.False(t, bankKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)}))
-	require.False(t, bankKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 5)}))
+	require.True(t, bankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
+	require.True(t, bankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
+	require.False(t, bankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
+	require.False(t, bankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5))))
 
 	// Test AddCoins
-	bankKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 25)}))
+	bankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15)))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 25))))
 
-	bankKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 15)})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 15), sdk.NewInt64Coin("foocoin", 25)}))
+	bankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 15)))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 15), sdk.NewInt64Coin("foocoin", 25))))
 
 	// Test SubtractCoins
-	bankKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)})
-	bankKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 5)})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15)}))
+	bankKeeper.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
+	bankKeeper.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5)))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15))))
 
-	bankKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 11)})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15)}))
+	bankKeeper.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 11)))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15))))
 
-	bankKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 10)})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 15)}))
-	require.False(t, bankKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 1)}))
+	bankKeeper.SubtractCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10)))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
+	require.False(t, bankKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 1))))
 
 	// Test SendCoins
-	bankKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
-	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
+	bankKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5)))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
+	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
 
-	_, err2 := bankKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 50)})
+	_, err2 := bankKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 50)))
 	require.Implements(t, (*sdk.Error)(nil), err2)
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
-	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
+	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
 
-	bankKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 30)})
-	bankKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5)}))
-	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10)}))
+	bankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 30)))
+	bankKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5))))
+	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10))))
 
 	// Test InputOutputCoins
-	input1 := NewInput(addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 2)})
-	output1 := NewOutput(addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 2)})
+	input1 := NewInput(addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 2)))
+	output1 := NewOutput(addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 2)))
 	bankKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1})
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 7)}))
-	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 8)}))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 7))))
+	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 8))))
 
 	inputs := []Input{
-		NewInput(addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 3)}),
-		NewInput(addr2, sdk.Coins{sdk.NewInt64Coin("barcoin", 3), sdk.NewInt64Coin("foocoin", 2)}),
+		NewInput(addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 3))),
+		NewInput(addr2, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 3), sdk.NewInt64Coin("foocoin", 2))),
 	}
 
 	outputs := []Output{
-		NewOutput(addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 1)}),
-		NewOutput(addr3, sdk.Coins{sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5)}),
+		NewOutput(addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 1))),
+		NewOutput(addr3, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5))),
 	}
 	bankKeeper.InputOutputCoins(ctx, inputs, outputs)
-	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 21), sdk.NewInt64Coin("foocoin", 4)}))
-	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 7), sdk.NewInt64Coin("foocoin", 6)}))
-	require.True(t, bankKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5)}))
+	require.True(t, bankKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 21), sdk.NewInt64Coin("foocoin", 4))))
+	require.True(t, bankKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 7), sdk.NewInt64Coin("foocoin", 6))))
+	require.True(t, bankKeeper.GetCoins(ctx, addr3).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5))))
 }
 
 func TestSendKeeper(t *testing.T) {
@@ -147,33 +147,33 @@ func TestSendKeeper(t *testing.T) {
 
 	// Test GetCoins/SetCoins
 	input.ak.SetAccount(ctx, acc)
-	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
+	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins()))
 
-	bankKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)})
-	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
+	bankKeeper.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
+	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
 
 	// Test HasCoins
-	require.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
-	require.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
-	require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)}))
-	require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 5)}))
+	require.True(t, sendKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
+	require.True(t, sendKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
+	require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
+	require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5))))
 
-	bankKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)})
+	bankKeeper.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15)))
 
 	// Test SendCoins
-	sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)})
-	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
-	require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
+	sendKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5)))
+	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
+	require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
 
-	_, err := sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 50)})
+	_, err := sendKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 50)))
 	require.Implements(t, (*sdk.Error)(nil), err)
-	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
-	require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
+	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
+	require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
 
-	bankKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 30)})
-	sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)})
-	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5)}))
-	require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10)}))
+	bankKeeper.AddCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 30)))
+	sendKeeper.SendCoins(ctx, addr, addr2, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)))
+	require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5))))
+	require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10))))
 
 	// validate coins with invalid denoms or negative values cannot be sent
 	// NOTE: We must use the Coin literal as the constructor does not allow
@@ -195,16 +195,16 @@ func TestViewKeeper(t *testing.T) {
 
 	// Test GetCoins/SetCoins
 	input.ak.SetAccount(ctx, acc)
-	require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
+	require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins()))
 
-	bankKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)})
-	require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
+	bankKeeper.SetCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10)))
+	require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
 
 	// Test HasCoins
-	require.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
-	require.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
-	require.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)}))
-	require.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 5)}))
+	require.True(t, viewKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 10))))
+	require.True(t, viewKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 5))))
+	require.False(t, viewKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("foocoin", 15))))
+	require.False(t, viewKeeper.HasCoins(ctx, addr, sdk.NewCoins(sdk.NewInt64Coin("barcoin", 5))))
 }
 
 func TestVestingAccountSend(t *testing.T) {
@@ -213,8 +213,8 @@ func TestVestingAccountSend(t *testing.T) {
 	ctx := input.ctx.WithBlockHeader(abci.Header{Time: now})
 	endTime := now.Add(24 * time.Hour)
 
-	origCoins := sdk.Coins{sdk.NewInt64Coin("steak", 100)}
-	sendCoins := sdk.Coins{sdk.NewInt64Coin("steak", 50)}
+	origCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 100))
+	sendCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 50))
 	bankKeeper := NewBaseKeeper(input.ak, input.pk.Subspace(DefaultParamspace), DefaultCodespace)
 	bankKeeper.SetSendEnabled(ctx, true)
 
@@ -247,8 +247,8 @@ func TestVestingAccountReceive(t *testing.T) {
 	ctx := input.ctx.WithBlockHeader(abci.Header{Time: now})
 	endTime := now.Add(24 * time.Hour)
 
-	origCoins := sdk.Coins{sdk.NewInt64Coin("steak", 100)}
-	sendCoins := sdk.Coins{sdk.NewInt64Coin("steak", 50)}
+	origCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 100))
+	sendCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 50))
 	bankKeeper := NewBaseKeeper(input.ak, input.pk.Subspace(DefaultParamspace), DefaultCodespace)
 	bankKeeper.SetSendEnabled(ctx, true)
 
@@ -281,8 +281,8 @@ func TestDelegateCoins(t *testing.T) {
 	ctx := input.ctx.WithBlockHeader(abci.Header{Time: now})
 	endTime := now.Add(24 * time.Hour)
 
-	origCoins := sdk.Coins{sdk.NewInt64Coin("steak", 100)}
-	delCoins := sdk.Coins{sdk.NewInt64Coin("steak", 50)}
+	origCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 100))
+	delCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 50))
 	bankKeeper := NewBaseKeeper(input.ak, input.pk.Subspace(DefaultParamspace), DefaultCodespace)
 	bankKeeper.SetSendEnabled(ctx, true)
 
@@ -318,8 +318,8 @@ func TestUndelegateCoins(t *testing.T) {
 	ctx := input.ctx.WithBlockHeader(abci.Header{Time: now})
 	endTime := now.Add(24 * time.Hour)
 
-	origCoins := sdk.Coins{sdk.NewInt64Coin("steak", 100)}
-	delCoins := sdk.Coins{sdk.NewInt64Coin("steak", 50)}
+	origCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 100))
+	delCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 50))
 	bankKeeper := NewBaseKeeper(input.ak, input.pk.Subspace(DefaultParamspace), DefaultCodespace)
 	bankKeeper.SetSendEnabled(ctx, true)
 
diff --git a/x/bank/msgs_test.go b/x/bank/msgs_test.go
index baec34bcf..521e81761 100644
--- a/x/bank/msgs_test.go
+++ b/x/bank/msgs_test.go
@@ -12,7 +12,7 @@ import (
 func TestMsgSendRoute(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte("from"))
 	addr2 := sdk.AccAddress([]byte("to"))
-	coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
+	coins := sdk.NewCoins(sdk.NewInt64Coin("atom", 10))
 	var msg = NewMsgSend(addr1, addr2, coins)
 
 	require.Equal(t, msg.Route(), "bank")
@@ -22,9 +22,9 @@ func TestMsgSendRoute(t *testing.T) {
 func TestMsgSendValidation(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte("from"))
 	addr2 := sdk.AccAddress([]byte("to"))
-	atom123 := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
-	atom0 := sdk.Coins{sdk.NewInt64Coin("atom", 0)}
-	atom123eth123 := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 123)}
+	atom123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
+	atom0 := sdk.NewCoins(sdk.NewInt64Coin("atom", 0))
+	atom123eth123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 123))
 	atom123eth0 := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 0)}
 
 	var emptyAddr sdk.AccAddress
@@ -41,12 +41,12 @@ func TestMsgSendValidation(t *testing.T) {
 		{false, NewMsgSend(addr1, emptyAddr, atom123)},  // empty to addr
 	}
 
-	for i, tc := range cases {
+	for _, tc := range cases {
 		err := tc.tx.ValidateBasic()
 		if tc.valid {
-			require.Nil(t, err, "%d: %+v", i, err)
+			require.Nil(t, err)
 		} else {
-			require.NotNil(t, err, "%d", i)
+			require.NotNil(t, err)
 		}
 	}
 }
@@ -54,7 +54,7 @@ func TestMsgSendValidation(t *testing.T) {
 func TestMsgSendGetSignBytes(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte("input"))
 	addr2 := sdk.AccAddress([]byte("output"))
-	coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
+	coins := sdk.NewCoins(sdk.NewInt64Coin("atom", 10))
 	var msg = NewMsgSend(addr1, addr2, coins)
 	res := msg.GetSignBytes()
 
@@ -63,7 +63,7 @@ func TestMsgSendGetSignBytes(t *testing.T) {
 }
 
 func TestMsgSendGetSigners(t *testing.T) {
-	var msg = NewMsgSend(sdk.AccAddress([]byte("input1")), sdk.AccAddress{}, sdk.Coins{})
+	var msg = NewMsgSend(sdk.AccAddress([]byte("input1")), sdk.AccAddress{}, sdk.NewCoins())
 	res := msg.GetSigners()
 	// TODO: fix this !
 	require.Equal(t, fmt.Sprintf("%v", res), "[696E70757431]")
@@ -73,7 +73,7 @@ func TestMsgMultiSendRoute(t *testing.T) {
 	// Construct a MsgSend
 	addr1 := sdk.AccAddress([]byte("input"))
 	addr2 := sdk.AccAddress([]byte("output"))
-	coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
+	coins := sdk.NewCoins(sdk.NewInt64Coin("atom", 10))
 	var msg = MsgMultiSend{
 		Inputs:  []Input{NewInput(addr1, coins)},
 		Outputs: []Output{NewOutput(addr2, coins)},
@@ -87,12 +87,12 @@ func TestMsgMultiSendRoute(t *testing.T) {
 func TestInputValidation(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte{1, 2})
 	addr2 := sdk.AccAddress([]byte{7, 8})
-	someCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
-	multiCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20)}
+	someCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
+	multiCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20))
 
 	var emptyAddr sdk.AccAddress
-	emptyCoins := sdk.Coins{}
-	emptyCoins2 := sdk.Coins{sdk.NewInt64Coin("eth", 0)}
+	emptyCoins := sdk.NewCoins()
+	emptyCoins2 := sdk.NewCoins(sdk.NewInt64Coin("eth", 0))
 	someEmptyCoins := sdk.Coins{sdk.NewInt64Coin("eth", 10), sdk.NewInt64Coin("atom", 0)}
 	unsortedCoins := sdk.Coins{sdk.NewInt64Coin("eth", 1), sdk.NewInt64Coin("atom", 1)}
 
@@ -125,12 +125,12 @@ func TestInputValidation(t *testing.T) {
 func TestOutputValidation(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte{1, 2})
 	addr2 := sdk.AccAddress([]byte{7, 8})
-	someCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
-	multiCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20)}
+	someCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
+	multiCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20))
 
 	var emptyAddr sdk.AccAddress
-	emptyCoins := sdk.Coins{}
-	emptyCoins2 := sdk.Coins{sdk.NewInt64Coin("eth", 0)}
+	emptyCoins := sdk.NewCoins()
+	emptyCoins2 := sdk.NewCoins(sdk.NewInt64Coin("eth", 0))
 	someEmptyCoins := sdk.Coins{sdk.NewInt64Coin("eth", 10), sdk.NewInt64Coin("atom", 0)}
 	unsortedCoins := sdk.Coins{sdk.NewInt64Coin("eth", 1), sdk.NewInt64Coin("atom", 1)}
 
@@ -163,10 +163,10 @@ func TestOutputValidation(t *testing.T) {
 func TestMsgMultiSendValidation(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte{1, 2})
 	addr2 := sdk.AccAddress([]byte{7, 8})
-	atom123 := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
-	atom124 := sdk.Coins{sdk.NewInt64Coin("atom", 124)}
-	eth123 := sdk.Coins{sdk.NewInt64Coin("eth", 123)}
-	atom123eth123 := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 123)}
+	atom123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
+	atom124 := sdk.NewCoins(sdk.NewInt64Coin("atom", 124))
+	eth123 := sdk.NewCoins(sdk.NewInt64Coin("eth", 123))
+	atom123eth123 := sdk.NewCoins(sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 123))
 
 	input1 := NewInput(addr1, atom123)
 	input2 := NewInput(addr1, eth123)
@@ -217,7 +217,7 @@ func TestMsgMultiSendValidation(t *testing.T) {
 func TestMsgMultiSendGetSignBytes(t *testing.T) {
 	addr1 := sdk.AccAddress([]byte("input"))
 	addr2 := sdk.AccAddress([]byte("output"))
-	coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
+	coins := sdk.NewCoins(sdk.NewInt64Coin("atom", 10))
 	var msg = MsgMultiSend{
 		Inputs:  []Input{NewInput(addr1, coins)},
 		Outputs: []Output{NewOutput(addr2, coins)},
@@ -250,7 +250,7 @@ func TestMsgSendSigners(t *testing.T) {
 		{7, 8, 9},
 	}
 
-	someCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
+	someCoins := sdk.NewCoins(sdk.NewInt64Coin("atom", 123))
 	inputs := make([]Input, len(signers))
 	for i, signer := range signers {
 		inputs[i] = NewInput(signer, someCoins)
diff --git a/x/bank/simulation/msgs.go b/x/bank/simulation/msgs.go
index 1e4c529a9..69ca7f99e 100644
--- a/x/bank/simulation/msgs.go
+++ b/x/bank/simulation/msgs.go
@@ -13,47 +13,32 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/mock"
-	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
 )
 
 // SendTx tests and runs a single msg send where both
 // accounts already exist.
-func SendMsg(mapper auth.AccountKeeper, bk bank.Keeper) simulation.Operation {
+func SimulateMsgSend(mapper auth.AccountKeeper, bk bank.Keeper) simulation.Operation {
 	handler := bank.NewHandler(bk)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
-		fromAcc, action, msg, abort := createSendMsg(r, ctx, accs, mapper)
-		if abort {
-			return action, nil, nil
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account) (
+		opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
+
+		fromAcc, comment, msg, ok := createMsgSend(r, ctx, accs, mapper)
+		opMsg = simulation.NewOperationMsg(msg, ok, comment)
+		if !ok {
+			return opMsg, nil, nil
 		}
 		err = sendAndVerifyMsgSend(app, mapper, msg, ctx, []crypto.PrivKey{fromAcc.PrivKey}, handler)
 		if err != nil {
-			return "", nil, err
+			return opMsg, nil, err
 		}
-		event("bank/sendAndVerifyTxSend/ok")
-
-		return action, nil, nil
+		return opMsg, nil, nil
 	}
 }
 
-// SendTx tests and runs a single tx send, with auth where both
-// accounts already exist.
-func SendTx(mapper auth.AccountKeeper) simulation.Operation {
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
-		fromAcc, action, msg, abort := createSendMsg(r, ctx, accs, mapper)
-		if abort {
-			return action, nil, nil
-		}
-		err = sendAndVerifyMsgSend(app, mapper, msg, ctx, []crypto.PrivKey{fromAcc.PrivKey}, nil)
-		if err != nil {
-			return "", nil, err
-		}
-		event("bank/sendAndVerifyTxSend/ok")
+func createMsgSend(r *rand.Rand, ctx sdk.Context, accs []simulation.Account, mapper auth.AccountKeeper) (
+	fromAcc simulation.Account, comment string, msg bank.MsgSend, ok bool) {
 
-		return action, nil, nil
-	}
-}
-
-func createSendMsg(r *rand.Rand, ctx sdk.Context, accs []simulation.Account, mapper auth.AccountKeeper) (fromAcc simulation.Account, action string, msg bank.MsgSend, abort bool) {
 	fromAcc = simulation.RandomAcc(r, accs)
 	toAcc := simulation.RandomAcc(r, accs)
 	// Disallow sending money to yourself
@@ -63,29 +48,21 @@ func createSendMsg(r *rand.Rand, ctx sdk.Context, accs []simulation.Account, map
 		}
 		toAcc = simulation.RandomAcc(r, accs)
 	}
-	toAddr := toAcc.Address
 	initFromCoins := mapper.GetAccount(ctx, fromAcc.Address).SpendableCoins(ctx.BlockHeader().Time)
 
 	if len(initFromCoins) == 0 {
-		return fromAcc, "skipping, no coins at all", msg, true
+		return fromAcc, "skipping, no coins at all", msg, false
 	}
 
 	denomIndex := r.Intn(len(initFromCoins))
 	amt, goErr := randPositiveInt(r, initFromCoins[denomIndex].Amount)
 	if goErr != nil {
-		return fromAcc, "skipping bank send due to account having no coins of denomination " + initFromCoins[denomIndex].Denom, msg, true
+		return fromAcc, "skipping bank send due to account having no coins of denomination " + initFromCoins[denomIndex].Denom, msg, false
 	}
 
-	action = fmt.Sprintf("%s is sending %s %s to %s",
-		fromAcc.Address.String(),
-		amt.String(),
-		initFromCoins[denomIndex].Denom,
-		toAddr.String(),
-	)
-
 	coins := sdk.Coins{sdk.NewCoin(initFromCoins[denomIndex].Denom, amt)}
 	msg = bank.NewMsgSend(fromAcc.Address, toAcc.Address, coins)
-	return
+	return fromAcc, "", msg, true
 }
 
 // Sends and verifies the transition of a msg send.
@@ -133,44 +110,29 @@ func sendAndVerifyMsgSend(app *baseapp.BaseApp, mapper auth.AccountKeeper, msg b
 	return nil
 }
 
-// SingleInputSendTx tests and runs a single msg multisend w/ auth, with one input and one output, where both
-// accounts already exist.
-func SingleInputMultiSendTx(mapper auth.AccountKeeper) simulation.Operation {
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
-		fromAcc, action, msg, abort := createSingleInputMsgMultiSend(r, ctx, accs, mapper)
-		if abort {
-			return action, nil, nil
-		}
-		err = sendAndVerifyMsgMultiSend(app, mapper, msg, ctx, []crypto.PrivKey{fromAcc.PrivKey}, nil)
-		if err != nil {
-			return "", nil, err
-		}
-		event("bank/sendAndVerifyTxMultiSend/ok")
-
-		return action, nil, nil
-	}
-}
-
 // SingleInputSendMsg tests and runs a single msg multisend, with one input and one output, where both
 // accounts already exist.
-func SingleInputMsgMultiSend(mapper auth.AccountKeeper, bk bank.Keeper) simulation.Operation {
+func SimulateSingleInputMsgMultiSend(mapper auth.AccountKeeper, bk bank.Keeper) simulation.Operation {
 	handler := bank.NewHandler(bk)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
-		fromAcc, action, msg, abort := createSingleInputMsgMultiSend(r, ctx, accs, mapper)
-		if abort {
-			return action, nil, nil
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account) (
+		opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
+
+		fromAcc, comment, msg, ok := createSingleInputMsgMultiSend(r, ctx, accs, mapper)
+		opMsg = simulation.NewOperationMsg(msg, ok, comment)
+		if !ok {
+			return opMsg, nil, nil
 		}
 		err = sendAndVerifyMsgMultiSend(app, mapper, msg, ctx, []crypto.PrivKey{fromAcc.PrivKey}, handler)
 		if err != nil {
-			return "", nil, err
+			return opMsg, nil, err
 		}
-		event("bank/sendAndVerifyMsgMultiSend/ok")
-
-		return action, nil, nil
+		return opMsg, nil, nil
 	}
 }
 
-func createSingleInputMsgMultiSend(r *rand.Rand, ctx sdk.Context, accs []simulation.Account, mapper auth.AccountKeeper) (fromAcc simulation.Account, action string, msg bank.MsgMultiSend, abort bool) {
+func createSingleInputMsgMultiSend(r *rand.Rand, ctx sdk.Context, accs []simulation.Account, mapper auth.AccountKeeper) (
+	fromAcc simulation.Account, comment string, msg bank.MsgMultiSend, ok bool) {
+
 	fromAcc = simulation.RandomAcc(r, accs)
 	toAcc := simulation.RandomAcc(r, accs)
 	// Disallow sending money to yourself
@@ -184,33 +146,28 @@ func createSingleInputMsgMultiSend(r *rand.Rand, ctx sdk.Context, accs []simulat
 	initFromCoins := mapper.GetAccount(ctx, fromAcc.Address).SpendableCoins(ctx.BlockHeader().Time)
 
 	if len(initFromCoins) == 0 {
-		return fromAcc, "skipping, no coins at all", msg, true
+		return fromAcc, "skipping, no coins at all", msg, false
 	}
 
 	denomIndex := r.Intn(len(initFromCoins))
 	amt, goErr := randPositiveInt(r, initFromCoins[denomIndex].Amount)
 	if goErr != nil {
-		return fromAcc, "skipping bank send due to account having no coins of denomination " + initFromCoins[denomIndex].Denom, msg, true
+		return fromAcc, "skipping bank send due to account having no coins of denomination " + initFromCoins[denomIndex].Denom, msg, false
 	}
 
-	action = fmt.Sprintf("%s is sending %s %s to %s",
-		fromAcc.Address.String(),
-		amt.String(),
-		initFromCoins[denomIndex].Denom,
-		toAddr.String(),
-	)
-
 	coins := sdk.Coins{sdk.NewCoin(initFromCoins[denomIndex].Denom, amt)}
 	msg = bank.MsgMultiSend{
 		Inputs:  []bank.Input{bank.NewInput(fromAcc.Address, coins)},
 		Outputs: []bank.Output{bank.NewOutput(toAddr, coins)},
 	}
-	return
+	return fromAcc, "", msg, true
 }
 
 // Sends and verifies the transition of a msg multisend. This fails if there are repeated inputs or outputs
 // pass in handler as nil to handle txs, otherwise handle msgs
-func sendAndVerifyMsgMultiSend(app *baseapp.BaseApp, mapper auth.AccountKeeper, msg bank.MsgMultiSend, ctx sdk.Context, privkeys []crypto.PrivKey, handler sdk.Handler) error {
+func sendAndVerifyMsgMultiSend(app *baseapp.BaseApp, mapper auth.AccountKeeper, msg bank.MsgMultiSend,
+	ctx sdk.Context, privkeys []crypto.PrivKey, handler sdk.Handler) error {
+
 	initialInputAddrCoins := make([]sdk.Coins, len(msg.Inputs))
 	initialOutputAddrCoins := make([]sdk.Coins, len(msg.Outputs))
 	AccountNumbers := make([]uint64, len(msg.Inputs))
diff --git a/x/crisis/client/cli/tx.go b/x/crisis/client/cli/tx.go
new file mode 100644
index 000000000..d44759ea4
--- /dev/null
+++ b/x/crisis/client/cli/tx.go
@@ -0,0 +1,33 @@
+// nolint
+package cli
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/client/utils"
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
+	"github.com/cosmos/cosmos-sdk/x/crisis"
+)
+
+// command to replace a delegator's withdrawal address
+func GetCmdInvariantBroken(cdc *codec.Codec) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "invariant-broken [module-name] [invariant-route]",
+		Short: "submit proof that an invariant broken to halt the chain",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+
+			txBldr := authtxb.NewTxBuilderFromCLI().WithTxEncoder(utils.GetTxEncoder(cdc))
+			cliCtx := context.NewCLIContext().WithCodec(cdc).WithAccountDecoder(cdc)
+
+			senderAddr := cliCtx.GetFromAddress()
+			moduleName, route := args[0], args[1]
+			msg := crisis.NewMsgVerifyInvariant(senderAddr, moduleName, route)
+			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}, false)
+		},
+	}
+	return cmd
+}
diff --git a/x/crisis/client/module_client.go b/x/crisis/client/module_client.go
new file mode 100644
index 000000000..12c9d2282
--- /dev/null
+++ b/x/crisis/client/module_client.go
@@ -0,0 +1,42 @@
+package client
+
+import (
+	"github.com/spf13/cobra"
+	amino "github.com/tendermint/go-amino"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/x/crisis"
+	"github.com/cosmos/cosmos-sdk/x/crisis/client/cli"
+)
+
+// ModuleClient exports all client functionality from this module
+type ModuleClient struct {
+	storeKey string
+	cdc      *amino.Codec
+}
+
+// NewModuleClient creates a new ModuleClient object
+func NewModuleClient(storeKey string, cdc *amino.Codec) ModuleClient {
+	return ModuleClient{
+		storeKey: storeKey,
+		cdc:      cdc,
+	}
+}
+
+// GetQueryCmd returns the cli query commands for this module
+func (ModuleClient) GetQueryCmd() *cobra.Command {
+	return nil
+}
+
+// GetTxCmd returns the transaction commands for this module
+func (mc ModuleClient) GetTxCmd() *cobra.Command {
+	txCmd := &cobra.Command{
+		Use:   crisis.ModuleName,
+		Short: "crisis transactions subcommands",
+	}
+
+	txCmd.AddCommand(client.PostCommands(
+		cli.GetCmdInvariantBroken(mc.cdc),
+	)...)
+	return txCmd
+}
diff --git a/x/crisis/codec.go b/x/crisis/codec.go
new file mode 100644
index 000000000..d52176764
--- /dev/null
+++ b/x/crisis/codec.go
@@ -0,0 +1,20 @@
+package crisis
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+)
+
+// Register concrete types on codec codec
+func RegisterCodec(cdc *codec.Codec) {
+	cdc.RegisterConcrete(MsgVerifyInvariant{}, "cosmos-sdk/MsgVerifyInvariant", nil)
+}
+
+// generic sealed codec to be used throughout module
+var MsgCdc *codec.Codec
+
+func init() {
+	cdc := codec.New()
+	RegisterCodec(cdc)
+	codec.RegisterCrypto(cdc)
+	MsgCdc = cdc.Seal()
+}
diff --git a/x/crisis/errors.go b/x/crisis/errors.go
new file mode 100644
index 000000000..7a03134fd
--- /dev/null
+++ b/x/crisis/errors.go
@@ -0,0 +1,23 @@
+package crisis
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+const (
+	// default codespace for crisis module
+	DefaultCodespace sdk.CodespaceType = ModuleName
+
+	// CodeInvalidInput is the codetype for invalid input for the crisis module
+	CodeInvalidInput sdk.CodeType = 103
+)
+
+// ErrNilSender -  no sender provided for the input
+func ErrNilSender(codespace sdk.CodespaceType) sdk.Error {
+	return sdk.NewError(codespace, CodeInvalidInput, "sender address is nil")
+}
+
+// ErrUnknownInvariant -  unknown invariant provided
+func ErrUnknownInvariant(codespace sdk.CodespaceType) sdk.Error {
+	return sdk.NewError(codespace, CodeInvalidInput, "unknown invariant")
+}
diff --git a/x/crisis/expected_keepers.go b/x/crisis/expected_keepers.go
new file mode 100644
index 000000000..e620bdd3a
--- /dev/null
+++ b/x/crisis/expected_keepers.go
@@ -0,0 +1,20 @@
+package crisis
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// expected bank keeper
+type DistrKeeper interface {
+	DistributeFeePool(ctx sdk.Context, amount sdk.Coins, receiveAddr sdk.AccAddress) sdk.Error
+}
+
+// expected fee collection keeper
+type FeeCollectionKeeper interface {
+	AddCollectedFees(ctx sdk.Context, coins sdk.Coins) sdk.Coins
+}
+
+// expected bank keeper
+type BankKeeper interface {
+	SubtractCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error)
+}
diff --git a/x/crisis/genesis.go b/x/crisis/genesis.go
new file mode 100644
index 000000000..7cd702b84
--- /dev/null
+++ b/x/crisis/genesis.go
@@ -0,0 +1,40 @@
+package crisis
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// GenesisState - crisis genesis state
+type GenesisState struct {
+	ConstantFee sdk.Coin `json:"constant_fee"`
+}
+
+// NewGenesisState creates a new GenesisState object
+func NewGenesisState(constantFee sdk.Coin) GenesisState {
+	return GenesisState{
+		ConstantFee: constantFee,
+	}
+}
+
+// DefaultGenesisState creates a default GenesisState object
+func DefaultGenesisState() GenesisState {
+	return GenesisState{
+		ConstantFee: sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000)),
+	}
+}
+
+// new crisis genesis
+func InitGenesis(ctx sdk.Context, keeper Keeper, data GenesisState) {
+	keeper.SetConstantFee(ctx, data.ConstantFee)
+}
+
+// ExportGenesis returns a GenesisState for a given context and keeper.
+func ExportGenesis(ctx sdk.Context, keeper Keeper) GenesisState {
+	constantFee := keeper.GetConstantFee(ctx)
+	return NewGenesisState(constantFee)
+}
+
+// ValidateGenesis - placeholder function
+func ValidateGenesis(data GenesisState) error {
+	return nil
+}
diff --git a/x/crisis/handler.go b/x/crisis/handler.go
new file mode 100644
index 000000000..ae753804d
--- /dev/null
+++ b/x/crisis/handler.go
@@ -0,0 +1,80 @@
+package crisis
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// ModuleName is the module name for this module
+const (
+	ModuleName = "crisis"
+	RouterKey  = ModuleName
+)
+
+func NewHandler(k Keeper) sdk.Handler {
+	return func(ctx sdk.Context, msg sdk.Msg) sdk.Result {
+
+		switch msg := msg.(type) {
+		case MsgVerifyInvariant:
+			return handleMsgVerifyInvariant(ctx, msg, k)
+		default:
+			return sdk.ErrTxDecode("invalid message parse in crisis module").Result()
+		}
+	}
+}
+
+func handleMsgVerifyInvariant(ctx sdk.Context, msg MsgVerifyInvariant, k Keeper) sdk.Result {
+
+	// remove the constant fee
+	constantFee := sdk.NewCoins(k.GetConstantFee(ctx))
+	_, _, err := k.bankKeeper.SubtractCoins(ctx, msg.Sender, constantFee)
+	if err != nil {
+		return err.Result()
+	}
+	_ = k.feeCollectionKeeper.AddCollectedFees(ctx, constantFee)
+
+	// use a cached context to avoid gas costs during invariants
+	cacheCtx, _ := ctx.CacheContext()
+
+	found := false
+	var invarianceErr error
+	msgFullRoute := msg.FullInvariantRoute()
+	for _, invarRoute := range k.routes {
+		if invarRoute.FullRoute() == msgFullRoute {
+			invarianceErr = invarRoute.Invar(cacheCtx)
+			found = true
+			break
+		}
+	}
+	if !found {
+		return ErrUnknownInvariant(DefaultCodespace).Result()
+	}
+
+	if invarianceErr != nil {
+
+		// NOTE currently, because the chain halts here, this transaction will never be included
+		// in the blockchain thus the constant fee will have never been deducted. Thus no
+		// refund is required.
+
+		// TODO uncomment the following code block with implementation of the circuit breaker
+		//// refund constant fee
+		//err := k.distrKeeper.DistributeFeePool(ctx, constantFee, msg.Sender)
+		//if err != nil {
+		//// if there are insufficient coins to refund, log the error,
+		//// but still halt the chain.
+		//logger := ctx.Logger().With("module", "x/crisis")
+		//logger.Error(fmt.Sprintf(
+		//"WARNING: insufficient funds to allocate to sender from fee pool, err: %s", err))
+		//}
+
+		// TODO replace with circuit breaker
+		panic(invarianceErr)
+	}
+
+	tags := sdk.NewTags(
+		"sender", msg.Sender.String(),
+		"invariant", msg.InvariantRoute,
+	)
+	return sdk.Result{
+		Tags: tags,
+	}
+}
diff --git a/x/crisis/handler_test.go b/x/crisis/handler_test.go
new file mode 100644
index 000000000..1f0aa6d14
--- /dev/null
+++ b/x/crisis/handler_test.go
@@ -0,0 +1,100 @@
+package crisis
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	distr "github.com/cosmos/cosmos-sdk/x/distribution"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	testModuleName        = "dummy"
+	dummyRouteWhichPasses = NewInvarRoute(testModuleName, "which-passes", func(_ sdk.Context) error { return nil })
+	dummyRouteWhichFails  = NewInvarRoute(testModuleName, "which-fails", func(_ sdk.Context) error { return errors.New("whoops") })
+	addrs                 = distr.TestAddrs
+)
+
+func CreateTestInput(t *testing.T) (sdk.Context, Keeper, auth.AccountKeeper, distr.Keeper) {
+
+	communityTax := sdk.NewDecWithPrec(2, 2)
+	ctx, accKeeper, bankKeeper, distrKeeper, _, feeCollectionKeeper, paramsKeeper :=
+		distr.CreateTestInputAdvanced(t, false, 10, communityTax)
+
+	paramSpace := paramsKeeper.Subspace(DefaultParamspace)
+	crisisKeeper := NewKeeper(paramSpace, distrKeeper, bankKeeper, feeCollectionKeeper)
+	constantFee := sdk.NewInt64Coin("stake", 10000000)
+	crisisKeeper.SetConstantFee(ctx, constantFee)
+
+	crisisKeeper.RegisterRoute(testModuleName, dummyRouteWhichPasses.Route, dummyRouteWhichPasses.Invar)
+	crisisKeeper.RegisterRoute(testModuleName, dummyRouteWhichFails.Route, dummyRouteWhichFails.Invar)
+
+	// set the community pool to pay back the constant fee
+	feePool := distr.InitialFeePool()
+	feePool.CommunityPool = sdk.NewDecCoins(sdk.NewCoins(constantFee))
+	distrKeeper.SetFeePool(ctx, feePool)
+
+	return ctx, crisisKeeper, accKeeper, distrKeeper
+}
+
+//____________________________________________________________________________
+
+func TestHandleMsgVerifyInvariantWithNotEnoughSenderCoins(t *testing.T) {
+	ctx, crisisKeeper, accKeeper, _ := CreateTestInput(t)
+	sender := addrs[0]
+	coin := accKeeper.GetAccount(ctx, sender).GetCoins()[0]
+	excessCoins := sdk.NewCoin(coin.Denom, coin.Amount.AddRaw(1))
+	crisisKeeper.SetConstantFee(ctx, excessCoins)
+
+	msg := NewMsgVerifyInvariant(sender, testModuleName, dummyRouteWhichPasses.Route)
+	res := handleMsgVerifyInvariant(ctx, msg, crisisKeeper)
+	require.False(t, res.IsOK())
+}
+
+func TestHandleMsgVerifyInvariantWithBadInvariant(t *testing.T) {
+	ctx, crisisKeeper, _, _ := CreateTestInput(t)
+	sender := addrs[0]
+
+	msg := NewMsgVerifyInvariant(sender, testModuleName, "route-that-doesnt-exist")
+	res := handleMsgVerifyInvariant(ctx, msg, crisisKeeper)
+	require.False(t, res.IsOK())
+}
+
+func TestHandleMsgVerifyInvariantWithInvariantBroken(t *testing.T) {
+	ctx, crisisKeeper, _, _ := CreateTestInput(t)
+	sender := addrs[0]
+
+	msg := NewMsgVerifyInvariant(sender, testModuleName, dummyRouteWhichFails.Route)
+	var res sdk.Result
+	require.Panics(t, func() {
+		res = handleMsgVerifyInvariant(ctx, msg, crisisKeeper)
+	}, fmt.Sprintf("%v", res))
+}
+
+func TestHandleMsgVerifyInvariantWithInvariantBrokenAndNotEnoughPoolCoins(t *testing.T) {
+	ctx, crisisKeeper, _, distrKeeper := CreateTestInput(t)
+	sender := addrs[0]
+
+	// set the community pool to empty
+	feePool := distrKeeper.GetFeePool(ctx)
+	feePool.CommunityPool = sdk.DecCoins{}
+	distrKeeper.SetFeePool(ctx, feePool)
+
+	msg := NewMsgVerifyInvariant(sender, testModuleName, dummyRouteWhichFails.Route)
+	var res sdk.Result
+	require.Panics(t, func() {
+		res = handleMsgVerifyInvariant(ctx, msg, crisisKeeper)
+	}, fmt.Sprintf("%v", res))
+}
+
+func TestHandleMsgVerifyInvariantWithInvariantNotBroken(t *testing.T) {
+	ctx, crisisKeeper, _, _ := CreateTestInput(t)
+	sender := addrs[0]
+
+	msg := NewMsgVerifyInvariant(sender, testModuleName, dummyRouteWhichPasses.Route)
+	res := handleMsgVerifyInvariant(ctx, msg, crisisKeeper)
+	require.True(t, res.IsOK())
+}
diff --git a/x/crisis/keeper.go b/x/crisis/keeper.go
new file mode 100644
index 000000000..8501b08ee
--- /dev/null
+++ b/x/crisis/keeper.go
@@ -0,0 +1,41 @@
+package crisis
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/params"
+)
+
+// Keeper - crisis keeper
+type Keeper struct {
+	routes     []InvarRoute
+	paramSpace params.Subspace
+
+	distrKeeper         DistrKeeper
+	bankKeeper          BankKeeper
+	feeCollectionKeeper FeeCollectionKeeper
+}
+
+// NewKeeper creates a new Keeper object
+func NewKeeper(paramSpace params.Subspace,
+	distrKeeper DistrKeeper, bankKeeper BankKeeper,
+	feeCollectionKeeper FeeCollectionKeeper) Keeper {
+
+	return Keeper{
+		routes:              []InvarRoute{},
+		paramSpace:          paramSpace.WithKeyTable(ParamKeyTable()),
+		distrKeeper:         distrKeeper,
+		bankKeeper:          bankKeeper,
+		feeCollectionKeeper: feeCollectionKeeper,
+	}
+}
+
+// register routes for the
+func (k *Keeper) RegisterRoute(moduleName, route string, invar sdk.Invariant) {
+	invarRoute := NewInvarRoute(moduleName, route, invar)
+	k.routes = append(k.routes, invarRoute)
+}
+
+// Routes - return the keeper's invariant routes
+func (k Keeper) Routes() []InvarRoute {
+	return k.routes
+}
diff --git a/x/crisis/msg.go b/x/crisis/msg.go
new file mode 100644
index 000000000..d6289d2b4
--- /dev/null
+++ b/x/crisis/msg.go
@@ -0,0 +1,52 @@
+package crisis
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// MsgVerifyInvariant - message struct to verify a particular invariance
+type MsgVerifyInvariant struct {
+	Sender              sdk.AccAddress `json:"sender"`
+	InvariantModuleName string         `json:"invariant_module_name"`
+	InvariantRoute      string         `json:"invariant_route"`
+}
+
+// ensure Msg interface compliance at compile time
+var _ sdk.Msg = &MsgVerifyInvariant{}
+
+// NewMsgVerifyInvariant creates a new MsgVerifyInvariant object
+func NewMsgVerifyInvariant(sender sdk.AccAddress, invariantModuleName,
+	invariantRoute string) MsgVerifyInvariant {
+
+	return MsgVerifyInvariant{
+		Sender:              sender,
+		InvariantModuleName: invariantModuleName,
+		InvariantRoute:      invariantRoute,
+	}
+}
+
+//nolint
+func (msg MsgVerifyInvariant) Route() string { return ModuleName }
+func (msg MsgVerifyInvariant) Type() string  { return "verify_invariant" }
+
+// get the bytes for the message signer to sign on
+func (msg MsgVerifyInvariant) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Sender} }
+
+// GetSignBytes gets the sign bytes for the msg MsgVerifyInvariant
+func (msg MsgVerifyInvariant) GetSignBytes() []byte {
+	bz := MsgCdc.MustMarshalJSON(msg)
+	return sdk.MustSortJSON(bz)
+}
+
+// quick validity check
+func (msg MsgVerifyInvariant) ValidateBasic() sdk.Error {
+	if msg.Sender.Empty() {
+		return ErrNilSender(DefaultCodespace)
+	}
+	return nil
+}
+
+// FullInvariantRoute - get the messages full invariant route
+func (msg MsgVerifyInvariant) FullInvariantRoute() string {
+	return msg.InvariantModuleName + "/" + msg.InvariantRoute
+}
diff --git a/x/crisis/params.go b/x/crisis/params.go
new file mode 100644
index 000000000..14c8a2567
--- /dev/null
+++ b/x/crisis/params.go
@@ -0,0 +1,34 @@
+package crisis
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/params"
+)
+
+// Default parameter namespace
+const (
+	DefaultParamspace = ModuleName
+)
+
+var (
+	// key for constant fee parameter
+	ParamStoreKeyConstantFee = []byte("ConstantFee")
+)
+
+// type declaration for parameters
+func ParamKeyTable() params.KeyTable {
+	return params.NewKeyTable(
+		ParamStoreKeyConstantFee, sdk.Coin{},
+	)
+}
+
+// GetConstantFee get's the constant fee from the paramSpace
+func (k Keeper) GetConstantFee(ctx sdk.Context) (constantFee sdk.Coin) {
+	k.paramSpace.Get(ctx, ParamStoreKeyConstantFee, &constantFee)
+	return
+}
+
+// GetConstantFee set's the constant fee in the paramSpace
+func (k Keeper) SetConstantFee(ctx sdk.Context, constantFee sdk.Coin) {
+	k.paramSpace.Set(ctx, ParamStoreKeyConstantFee, constantFee)
+}
diff --git a/x/crisis/route.go b/x/crisis/route.go
new file mode 100644
index 000000000..0f8808581
--- /dev/null
+++ b/x/crisis/route.go
@@ -0,0 +1,26 @@
+package crisis
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// invariant route
+type InvarRoute struct {
+	ModuleName string
+	Route      string
+	Invar      sdk.Invariant
+}
+
+// NewInvarRoute - create an InvarRoute object
+func NewInvarRoute(moduleName, route string, invar sdk.Invariant) InvarRoute {
+	return InvarRoute{
+		ModuleName: moduleName,
+		Route:      route,
+		Invar:      invar,
+	}
+}
+
+// get the full invariance route
+func (i InvarRoute) FullRoute() string {
+	return i.ModuleName + "/" + i.Route
+}
diff --git a/x/distribution/abci_app.go b/x/distribution/abci_app.go
index aae399062..0a2ef5627 100644
--- a/x/distribution/abci_app.go
+++ b/x/distribution/abci_app.go
@@ -11,11 +11,11 @@ import (
 func BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock, k keeper.Keeper) {
 
 	// determine the total power signing the block
-	var totalPower, sumPrecommitPower int64
+	var previousTotalPower, sumPreviousPrecommitPower int64
 	for _, voteInfo := range req.LastCommitInfo.GetVotes() {
-		totalPower += voteInfo.Validator.Power
+		previousTotalPower += voteInfo.Validator.Power
 		if voteInfo.SignedLastBlock {
-			sumPrecommitPower += voteInfo.Validator.Power
+			sumPreviousPrecommitPower += voteInfo.Validator.Power
 		}
 	}
 
@@ -23,7 +23,7 @@ func BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock, k keeper.Keeper)
 	// ref https://github.com/cosmos/cosmos-sdk/issues/3095
 	if ctx.BlockHeight() > 1 {
 		previousProposer := k.GetPreviousProposerConsAddr(ctx)
-		k.AllocateTokens(ctx, sumPrecommitPower, totalPower, previousProposer, req.LastCommitInfo.GetVotes())
+		k.AllocateTokens(ctx, sumPreviousPrecommitPower, previousTotalPower, previousProposer, req.LastCommitInfo.GetVotes())
 	}
 
 	// record the proposer for when we payout on the next block
diff --git a/x/distribution/alias.go b/x/distribution/alias.go
index 34ad7dd57..616991a47 100644
--- a/x/distribution/alias.go
+++ b/x/distribution/alias.go
@@ -59,6 +59,14 @@ var (
 	NewQueryDelegatorParams                   = keeper.NewQueryDelegatorParams
 	NewQueryDelegatorWithdrawAddrParams       = keeper.NewQueryDelegatorWithdrawAddrParams
 	DefaultParamspace                         = keeper.DefaultParamspace
+	RegisterInvariants                        = keeper.RegisterInvariants
+	AllInvariants                             = keeper.AllInvariants
+	NonNegativeOutstandingInvariant           = keeper.NonNegativeOutstandingInvariant
+	CanWithdrawInvariant                      = keeper.CanWithdrawInvariant
+	ReferenceCountInvariant                   = keeper.ReferenceCountInvariant
+	CreateTestInputDefault                    = keeper.CreateTestInputDefault
+	CreateTestInputAdvanced                   = keeper.CreateTestInputAdvanced
+	TestAddrs                                 = keeper.TestAddrs
 
 	RegisterCodec       = types.RegisterCodec
 	DefaultGenesisState = types.DefaultGenesisState
diff --git a/x/distribution/client/cli/query.go b/x/distribution/client/cli/query.go
index 4ba5b03b1..7c4c2bcbd 100644
--- a/x/distribution/client/cli/query.go
+++ b/x/distribution/client/cli/query.go
@@ -163,3 +163,28 @@ $ gaiacli query distr rewards cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p cosm
 		},
 	}
 }
+
+// GetCmdQueryCommunityPool returns the command for fetching community pool info
+func GetCmdQueryCommunityPool(queryRoute string, cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "community-pool",
+		Args:  cobra.NoArgs,
+		Short: "Query the amount of coins in the community pool",
+		Long: strings.TrimSpace(`Query all coins in the community pool which is under Governance control.
+
+$ gaiacli query distr community-pool
+`),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+
+			res, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/community_pool", queryRoute), nil)
+			if err != nil {
+				return err
+			}
+
+			var result sdk.DecCoins
+			cdc.MustUnmarshalJSON(res, &result)
+			return cliCtx.PrintOutput(result)
+		},
+	}
+}
diff --git a/x/distribution/client/module_client.go b/x/distribution/client/module_client.go
index 0acb62a72..780b0cabd 100644
--- a/x/distribution/client/module_client.go
+++ b/x/distribution/client/module_client.go
@@ -31,6 +31,7 @@ func (mc ModuleClient) GetQueryCmd() *cobra.Command {
 		distCmds.GetCmdQueryValidatorCommission(mc.storeKey, mc.cdc),
 		distCmds.GetCmdQueryValidatorSlashes(mc.storeKey, mc.cdc),
 		distCmds.GetCmdQueryDelegatorRewards(mc.storeKey, mc.cdc),
+		distCmds.GetCmdQueryCommunityPool(mc.storeKey, mc.cdc),
 	)...)
 
 	return distQueryCmd
diff --git a/x/distribution/client/rest/query.go b/x/distribution/client/rest/query.go
index a8a6e1326..919574b5e 100644
--- a/x/distribution/client/rest/query.go
+++ b/x/distribution/client/rest/query.go
@@ -61,6 +61,12 @@ func registerQueryRoutes(cliCtx context.CLIContext, r *mux.Router,
 		paramsHandlerFn(cliCtx, cdc, queryRoute),
 	).Methods("GET")
 
+	// Get the amount held in the community pool
+	r.HandleFunc(
+		"/distribution/community_pool",
+		communityPoolHandler(cliCtx, cdc, queryRoute),
+	).Methods("GET")
+
 }
 
 // HTTP request handler to query the total rewards balance from all delegations
@@ -207,6 +213,26 @@ func paramsHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec,
 	}
 }
 
+func communityPoolHandler(cliCtx context.CLIContext, cdc *codec.Codec,
+	queryRoute string) http.HandlerFunc {
+
+	return func(w http.ResponseWriter, r *http.Request) {
+		res, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/community_pool", queryRoute), nil)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		var result sdk.DecCoins
+		if err := cdc.UnmarshalJSON(res, &result); err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		rest.PostProcessResponse(w, cdc, result, cliCtx.Indent)
+	}
+}
+
 // HTTP request handler to query the outstanding rewards
 func outstandingRewardsHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec,
 	queryRoute string) http.HandlerFunc {
diff --git a/x/distribution/keeper/allocation.go b/x/distribution/keeper/allocation.go
index 50dcd2e93..df5be3b92 100644
--- a/x/distribution/keeper/allocation.go
+++ b/x/distribution/keeper/allocation.go
@@ -9,42 +9,45 @@ import (
 )
 
 // allocate fees handles distribution of the collected fees
-func (k Keeper) AllocateTokens(ctx sdk.Context, sumPrecommitPower, totalPower int64, proposer sdk.ConsAddress, votes []abci.VoteInfo) {
+func (k Keeper) AllocateTokens(ctx sdk.Context, sumPreviousPrecommitPower, totalPreviousPower int64,
+	previousProposer sdk.ConsAddress, previousVotes []abci.VoteInfo) {
+
 	logger := ctx.Logger().With("module", "x/distribution")
 
-	// fetch collected fees & fee pool
+	// fetch and clear the collected fees for distribution, since this is
+	// called in BeginBlock, collected fees will be from the previous block
+	// (and distributed to the previous proposer)
 	feesCollectedInt := k.feeCollectionKeeper.GetCollectedFees(ctx)
 	feesCollected := sdk.NewDecCoins(feesCollectedInt)
-	feePool := k.GetFeePool(ctx)
-
-	// clear collected fees, which will now be distributed
 	k.feeCollectionKeeper.ClearCollectedFees(ctx)
 
 	// temporary workaround to keep CanWithdrawInvariant happy
 	// general discussions here: https://github.com/cosmos/cosmos-sdk/issues/2906#issuecomment-441867634
-	if totalPower == 0 {
+	feePool := k.GetFeePool(ctx)
+	if totalPreviousPower == 0 {
 		feePool.CommunityPool = feePool.CommunityPool.Add(feesCollected)
 		k.SetFeePool(ctx, feePool)
 		return
 	}
 
 	// calculate fraction votes
-	fractionVotes := sdk.NewDec(sumPrecommitPower).Quo(sdk.NewDec(totalPower))
+	previousFractionVotes := sdk.NewDec(sumPreviousPrecommitPower).Quo(sdk.NewDec(totalPreviousPower))
 
-	// calculate proposer reward
+	// calculate previous proposer reward
 	baseProposerReward := k.GetBaseProposerReward(ctx)
 	bonusProposerReward := k.GetBonusProposerReward(ctx)
-	proposerMultiplier := baseProposerReward.Add(bonusProposerReward.MulTruncate(fractionVotes))
+	proposerMultiplier := baseProposerReward.Add(bonusProposerReward.MulTruncate(previousFractionVotes))
 	proposerReward := feesCollected.MulDecTruncate(proposerMultiplier)
 
-	// pay proposer
+	// pay previous proposer
 	remaining := feesCollected
-	proposerValidator := k.stakingKeeper.ValidatorByConsAddr(ctx, proposer)
+	proposerValidator := k.stakingKeeper.ValidatorByConsAddr(ctx, previousProposer)
+
 	if proposerValidator != nil {
 		k.AllocateTokensToValidator(ctx, proposerValidator, proposerReward)
 		remaining = remaining.Sub(proposerReward)
 	} else {
-		// proposer can be unknown if say, the unbonding period is 1 block, so
+		// previous proposer can be unknown if say, the unbonding period is 1 block, so
 		// e.g. a validator undelegates at block X, it's removed entirely by
 		// block X+1's endblock, then X+2 we need to refer to the previous
 		// proposer for X+1, but we've forgotten about them.
@@ -53,7 +56,7 @@ func (k Keeper) AllocateTokens(ctx sdk.Context, sumPrecommitPower, totalPower in
 				"This should happen only if the proposer unbonded completely within a single block, "+
 				"which generally should not happen except in exceptional circumstances (or fuzz testing). "+
 				"We recommend you investigate immediately.",
-			proposer.String()))
+			previousProposer.String()))
 	}
 
 	// calculate fraction allocated to validators
@@ -62,14 +65,13 @@ func (k Keeper) AllocateTokens(ctx sdk.Context, sumPrecommitPower, totalPower in
 
 	// allocate tokens proportionally to voting power
 	// TODO consider parallelizing later, ref https://github.com/cosmos/cosmos-sdk/pull/3099#discussion_r246276376
-	for _, vote := range votes {
+	for _, vote := range previousVotes {
 		validator := k.stakingKeeper.ValidatorByConsAddr(ctx, vote.Validator.Address)
 
 		// TODO consider microslashing for missing votes.
 		// ref https://github.com/cosmos/cosmos-sdk/issues/2525#issuecomment-430838701
-		powerFraction := sdk.NewDec(vote.Validator.Power).QuoTruncate(sdk.NewDec(totalPower))
+		powerFraction := sdk.NewDec(vote.Validator.Power).QuoTruncate(sdk.NewDec(totalPreviousPower))
 		reward := feesCollected.MulDecTruncate(voteMultiplier).MulDecTruncate(powerFraction)
-		reward = reward.Intersect(remaining)
 		k.AllocateTokensToValidator(ctx, validator, reward)
 		remaining = remaining.Sub(reward)
 	}
diff --git a/x/distribution/keeper/allocation_test.go b/x/distribution/keeper/allocation_test.go
index 8bbab7aef..956121d58 100644
--- a/x/distribution/keeper/allocation_test.go
+++ b/x/distribution/keeper/allocation_test.go
@@ -105,7 +105,7 @@ func TestAllocateTokensToManyValidators(t *testing.T) {
 
 func TestAllocateTokensTruncation(t *testing.T) {
 	communityTax := sdk.NewDec(0)
-	ctx, _, k, sk, fck := CreateTestInputAdvanced(t, false, 1000000, communityTax)
+	ctx, _, _, k, sk, fck, _ := CreateTestInputAdvanced(t, false, 1000000, communityTax)
 	sh := staking.NewHandler(sk)
 
 	// create validator with 10% commission
diff --git a/x/distribution/keeper/delegation.go b/x/distribution/keeper/delegation.go
index 00e7669bb..677c38342 100644
--- a/x/distribution/keeper/delegation.go
+++ b/x/distribution/keeper/delegation.go
@@ -22,7 +22,7 @@ func (k Keeper) initializeDelegation(ctx sdk.Context, val sdk.ValAddress, del sd
 	// calculate delegation stake in tokens
 	// we don't store directly, so multiply delegation shares * (tokens per share)
 	// note: necessary to truncate so we don't allow withdrawing more rewards than owed
-	stake := validator.ShareTokensTruncated(delegation.GetShares())
+	stake := validator.TokensFromSharesTruncated(delegation.GetShares())
 	k.SetDelegatorStartingInfo(ctx, val, del, types.NewDelegatorStartingInfo(previousPeriod, stake, uint64(ctx.BlockHeight())))
 }
 
@@ -64,13 +64,16 @@ func (k Keeper) calculateDelegationRewards(ctx sdk.Context, val sdk.Validator, d
 	startingPeriod := startingInfo.PreviousPeriod
 	stake := startingInfo.Stake
 
-	// iterate through slashes and withdraw with calculated staking for sub-intervals
-	// these offsets are dependent on *when* slashes happen - namely, in BeginBlock, after rewards are allocated...
-	// slashes which happened in the first block would have been before this delegation existed,
-	// UNLESS they were slashes of a redelegation to this validator which was itself slashed
-	// (from a fault committed by the redelegation source validator) earlier in the same BeginBlock
+	// Iterate through slashes and withdraw with calculated staking for
+	// distribution periods. These period offsets are dependent on *when* slashes
+	// happen - namely, in BeginBlock, after rewards are allocated...
+	// Slashes which happened in the first block would have been before this
+	// delegation existed, UNLESS they were slashes of a redelegation to this
+	// validator which was itself slashed (from a fault committed by the
+	// redelegation source validator) earlier in the same BeginBlock.
 	startingHeight := startingInfo.Height
-	// slashes this block happened after reward allocation, but we have to account for them for the stake sanity check below
+	// Slashes this block happened after reward allocation, but we have to account
+	// for them for the stake sanity check below.
 	endingHeight := uint64(ctx.BlockHeight())
 	if endingHeight > startingHeight {
 		k.IterateValidatorSlashEventsBetween(ctx, del.GetValidatorAddr(), startingHeight, endingHeight,
@@ -78,7 +81,9 @@ func (k Keeper) calculateDelegationRewards(ctx sdk.Context, val sdk.Validator, d
 				endingPeriod := event.ValidatorPeriod
 				if endingPeriod > startingPeriod {
 					rewards = rewards.Add(k.calculateDelegationRewardsBetween(ctx, val, startingPeriod, endingPeriod, stake))
-					// note: necessary to truncate so we don't allow withdrawing more rewards than owed
+
+					// Note: It is necessary to truncate so we don't allow withdrawing
+					// more rewards than owed.
 					stake = stake.MulTruncate(sdk.OneDec().Sub(event.Fraction))
 					startingPeriod = endingPeriod
 				}
@@ -87,18 +92,26 @@ func (k Keeper) calculateDelegationRewards(ctx sdk.Context, val sdk.Validator, d
 		)
 	}
 
-	// a stake sanity check - recalculated final stake should be less than or equal to current stake
-	// here we cannot use Equals because stake is truncated when multiplied by slash fractions
-	// we could only use equals if we had arbitrary-precision rationals
-	currentStake := val.ShareTokens(del.GetShares())
+	// A total stake sanity check; Recalculated final stake should be less than or
+	// equal to current stake here. We cannot use Equals because stake is truncated
+	// when multiplied by slash fractions (see above). We could only use equals if
+	// we had arbitrary-precision rationals.
+	currentStake := val.TokensFromShares(del.GetShares())
 	if stake.GT(currentStake) {
-		panic(fmt.Sprintf("calculated final stake for delegator %s greater than current stake: %s, %s",
-			del.GetDelegatorAddr(), stake, currentStake))
+		// account for rounding errors due to stake being multiplied by slash fractions
+		currentStakeRoundUp := val.TokensFromSharesRoundUp(del.GetShares())
+		if stake.Equal(currentStakeRoundUp) {
+			stake = currentStake
+		} else {
+			panic(fmt.Sprintf("calculated final stake for delegator %s greater than current stake"+
+				"\n\tfinal stake:\t%s"+
+				"\n\tcurrent stake:\t%s",
+				del.GetDelegatorAddr(), stake, currentStake))
+		}
 	}
 
 	// calculate rewards for final period
 	rewards = rewards.Add(k.calculateDelegationRewardsBetween(ctx, val, startingPeriod, endingPeriod, stake))
-
 	return rewards
 }
 
diff --git a/x/distribution/keeper/fee_pool.go b/x/distribution/keeper/fee_pool.go
new file mode 100644
index 000000000..d8e6998db
--- /dev/null
+++ b/x/distribution/keeper/fee_pool.go
@@ -0,0 +1,25 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/distribution/types"
+)
+
+// DistributeFeePool distributes funds from the the community pool to a receiver address
+func (k Keeper) DistributeFeePool(ctx sdk.Context, amount sdk.Coins, receiveAddr sdk.AccAddress) sdk.Error {
+	feePool := k.GetFeePool(ctx)
+
+	poolTruncated, _ := feePool.CommunityPool.TruncateDecimal()
+	if !poolTruncated.IsAllGTE(amount) {
+		return types.ErrBadDistribution(k.codespace)
+	}
+
+	feePool.CommunityPool.Sub(sdk.NewDecCoins(amount))
+	_, _, err := k.bankKeeper.AddCoins(ctx, receiveAddr, amount)
+	if err != nil {
+		return err
+	}
+
+	k.SetFeePool(ctx, feePool)
+	return nil
+}
diff --git a/x/distribution/simulation/invariants.go b/x/distribution/keeper/invariants.go
similarity index 78%
rename from x/distribution/simulation/invariants.go
rename to x/distribution/keeper/invariants.go
index 853e9494b..4eb2a5400 100644
--- a/x/distribution/simulation/invariants.go
+++ b/x/distribution/keeper/invariants.go
@@ -1,25 +1,34 @@
-package simulation
+package keeper
 
 import (
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	distr "github.com/cosmos/cosmos-sdk/x/distribution"
 	"github.com/cosmos/cosmos-sdk/x/distribution/types"
 )
 
+// register all distribution invariants
+func RegisterInvariants(c types.CrisisKeeper, k Keeper, stk types.StakingKeeper) {
+	c.RegisterRoute(types.ModuleName, "nonnegative-outstanding",
+		NonNegativeOutstandingInvariant(k))
+	c.RegisterRoute(types.ModuleName, "can-withdraw",
+		CanWithdrawInvariant(k, stk))
+	c.RegisterRoute(types.ModuleName, "reference-count",
+		ReferenceCountInvariant(k, stk))
+}
+
 // AllInvariants runs all invariants of the distribution module
-func AllInvariants(d distr.Keeper, stk types.StakingKeeper) sdk.Invariant {
+func AllInvariants(k Keeper, stk types.StakingKeeper) sdk.Invariant {
 	return func(ctx sdk.Context) error {
-		err := CanWithdrawInvariant(d, stk)(ctx)
+		err := CanWithdrawInvariant(k, stk)(ctx)
 		if err != nil {
 			return err
 		}
-		err = NonNegativeOutstandingInvariant(d)(ctx)
+		err = NonNegativeOutstandingInvariant(k)(ctx)
 		if err != nil {
 			return err
 		}
-		err = ReferenceCountInvariant(d, stk)(ctx)
+		err = ReferenceCountInvariant(k, stk)(ctx)
 		if err != nil {
 			return err
 		}
@@ -28,7 +37,7 @@ func AllInvariants(d distr.Keeper, stk types.StakingKeeper) sdk.Invariant {
 }
 
 // NonNegativeOutstandingInvariant checks that outstanding unwithdrawn fees are never negative
-func NonNegativeOutstandingInvariant(k distr.Keeper) sdk.Invariant {
+func NonNegativeOutstandingInvariant(k Keeper) sdk.Invariant {
 	return func(ctx sdk.Context) error {
 
 		var outstanding sdk.DecCoins
@@ -51,7 +60,7 @@ func NonNegativeOutstandingInvariant(k distr.Keeper) sdk.Invariant {
 }
 
 // CanWithdrawInvariant checks that current rewards can be completely withdrawn
-func CanWithdrawInvariant(k distr.Keeper, sk types.StakingKeeper) sdk.Invariant {
+func CanWithdrawInvariant(k Keeper, sk types.StakingKeeper) sdk.Invariant {
 	return func(ctx sdk.Context) error {
 
 		// cache, we don't want to write changes
@@ -95,7 +104,7 @@ func CanWithdrawInvariant(k distr.Keeper, sk types.StakingKeeper) sdk.Invariant
 }
 
 // ReferenceCountInvariant checks that the number of historical rewards records is correct
-func ReferenceCountInvariant(k distr.Keeper, sk types.StakingKeeper) sdk.Invariant {
+func ReferenceCountInvariant(k Keeper, sk types.StakingKeeper) sdk.Invariant {
 	return func(ctx sdk.Context) error {
 
 		valCount := uint64(0)
diff --git a/x/distribution/keeper/keeper.go b/x/distribution/keeper/keeper.go
index 0652a5166..5741893aa 100644
--- a/x/distribution/keeper/keeper.go
+++ b/x/distribution/keeper/keeper.go
@@ -79,9 +79,7 @@ func (k Keeper) WithdrawValidatorCommission(ctx sdk.Context, valAddr sdk.ValAddr
 	}
 
 	coins, remainder := commission.TruncateDecimal()
-
-	// leave remainder to withdraw later
-	k.SetValidatorAccumulatedCommission(ctx, valAddr, remainder)
+	k.SetValidatorAccumulatedCommission(ctx, valAddr, remainder) // leave remainder to withdraw later
 
 	// update outstanding
 	outstanding := k.GetValidatorOutstandingRewards(ctx, valAddr)
diff --git a/x/distribution/keeper/key.go b/x/distribution/keeper/key.go
index 068e05b85..c11b95368 100644
--- a/x/distribution/keeper/key.go
+++ b/x/distribution/keeper/key.go
@@ -4,11 +4,12 @@ import (
 	"encoding/binary"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/distribution/types"
 )
 
 const (
 	// default paramspace for params keeper
-	DefaultParamspace = "distr"
+	DefaultParamspace = types.ModuleName
 )
 
 // keys
diff --git a/x/distribution/keeper/querier.go b/x/distribution/keeper/querier.go
index 348c8b9a0..984bb7448 100644
--- a/x/distribution/keeper/querier.go
+++ b/x/distribution/keeper/querier.go
@@ -20,6 +20,7 @@ const (
 	QueryDelegatorTotalRewards       = "delegator_total_rewards"
 	QueryDelegatorValidators         = "delegator_validators"
 	QueryWithdrawAddr                = "withdraw_addr"
+	QueryCommunityPool               = "community_pool"
 
 	ParamCommunityTax        = "community_tax"
 	ParamBaseProposerReward  = "base_proposer_reward"
@@ -54,6 +55,9 @@ func NewQuerier(k Keeper) sdk.Querier {
 		case QueryWithdrawAddr:
 			return queryDelegatorWithdrawAddress(ctx, path[1:], req, k)
 
+		case QueryCommunityPool:
+			return queryCommunityPool(ctx, path[1:], req, k)
+
 		default:
 			return nil, sdk.ErrUnknownRequest("unknown distr query endpoint")
 		}
@@ -203,7 +207,17 @@ func queryDelegationRewards(ctx sdk.Context, _ []string, req abci.RequestQuery,
 	ctx, _ = ctx.CacheContext()
 
 	val := k.stakingKeeper.Validator(ctx, params.ValidatorAddress)
+	if val == nil {
+		// TODO: Should use ErrNoValidatorFound from staking/types
+		return nil, sdk.ErrInternal(fmt.Sprintf("validator %s does not exist", params.ValidatorAddress))
+	}
+
 	del := k.stakingKeeper.Delegation(ctx, params.DelegatorAddress, params.ValidatorAddress)
+	if del == nil {
+		// TODO: Should use ErrNoDelegation from staking/types
+		return nil, sdk.ErrInternal("delegation does not exist")
+	}
+
 	endingPeriod := k.incrementValidatorPeriod(ctx, val)
 	rewards := k.calculateDelegationRewards(ctx, val, del, endingPeriod)
 
@@ -314,3 +328,11 @@ func queryDelegatorWithdrawAddress(ctx sdk.Context, _ []string, req abci.Request
 
 	return bz, nil
 }
+
+func queryCommunityPool(ctx sdk.Context, _ []string, req abci.RequestQuery, k Keeper) ([]byte, sdk.Error) {
+	bz, err := k.cdc.MarshalJSON(k.GetFeePoolCommunityCoins(ctx))
+	if err != nil {
+		return nil, sdk.ErrInternal(sdk.AppendMsgToErr("could not marshal result to JSON", err.Error()))
+	}
+	return bz, nil
+}
diff --git a/x/distribution/keeper/querier_test.go b/x/distribution/keeper/querier_test.go
index 9593f1bff..8ba091bcf 100644
--- a/x/distribution/keeper/querier_test.go
+++ b/x/distribution/keeper/querier_test.go
@@ -109,6 +109,19 @@ func getQueriedDelegationRewards(t *testing.T, ctx sdk.Context, cdc *codec.Codec
 	return
 }
 
+func getQueriedCommunityPool(t *testing.T, ctx sdk.Context, cdc *codec.Codec, querier sdk.Querier) (ptr []byte) {
+	query := abci.RequestQuery{
+		Path: strings.Join([]string{custom, types.QuerierRoute, QueryCommunityPool}, ""),
+		Data: []byte{},
+	}
+
+	cp, err := querier(ctx, []string{QueryCommunityPool}, query)
+	require.Nil(t, err)
+	require.Nil(t, cdc.UnmarshalJSON(cp, &ptr))
+
+	return
+}
+
 func TestQueries(t *testing.T) {
 	cdc := codec.New()
 	ctx, _, keeper, sk, _ := CreateTestInputDefault(t, false, 100)
@@ -169,4 +182,8 @@ func TestQueries(t *testing.T) {
 	keeper.AllocateTokensToValidator(ctx, val, tokens)
 	rewards = getQueriedDelegationRewards(t, ctx, cdc, querier, sdk.AccAddress(valOpAddr1), valOpAddr1)
 	require.Equal(t, sdk.DecCoins{{sdk.DefaultBondDenom, sdk.NewDec(initial / 2)}}, rewards)
+
+	// currently community pool hold nothing so we should return null
+	communityPool := getQueriedCommunityPool(t, ctx, cdc, querier)
+	require.Nil(t, communityPool)
 }
diff --git a/x/distribution/keeper/store.go b/x/distribution/keeper/store.go
index 1326c89d4..894ef9c56 100644
--- a/x/distribution/keeper/store.go
+++ b/x/distribution/keeper/store.go
@@ -237,9 +237,16 @@ func (k Keeper) GetValidatorAccumulatedCommission(ctx sdk.Context, val sdk.ValAd
 
 // set accumulated commission for a validator
 func (k Keeper) SetValidatorAccumulatedCommission(ctx sdk.Context, val sdk.ValAddress, commission types.ValidatorAccumulatedCommission) {
+	var bz []byte
+
 	store := ctx.KVStore(k.storeKey)
-	b := k.cdc.MustMarshalBinaryLengthPrefixed(commission)
-	store.Set(GetValidatorAccumulatedCommissionKey(val), b)
+	if commission.IsZero() {
+		bz = k.cdc.MustMarshalBinaryLengthPrefixed(types.InitialValidatorAccumulatedCommission())
+	} else {
+		bz = k.cdc.MustMarshalBinaryLengthPrefixed(commission)
+	}
+
+	store.Set(GetValidatorAccumulatedCommissionKey(val), bz)
 }
 
 // delete accumulated commission for a validator
diff --git a/x/distribution/keeper/test_common.go b/x/distribution/keeper/test_common.go
index a17b4b5fe..032cd3dfa 100644
--- a/x/distribution/keeper/test_common.go
+++ b/x/distribution/keeper/test_common.go
@@ -47,7 +47,8 @@ var (
 	valConsAddr2 = sdk.ConsAddress(valConsPk2.Address())
 	valConsAddr3 = sdk.ConsAddress(valConsPk3.Address())
 
-	addrs = []sdk.AccAddress{
+	// test addresses
+	TestAddrs = []sdk.AccAddress{
 		delAddr1, delAddr2, delAddr3,
 		valAccAddr1, valAccAddr2, valAccAddr3,
 	}
@@ -75,13 +76,15 @@ func CreateTestInputDefault(t *testing.T, isCheckTx bool, initPower int64) (
 	sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, DummyFeeCollectionKeeper) {
 
 	communityTax := sdk.NewDecWithPrec(2, 2)
-	return CreateTestInputAdvanced(t, isCheckTx, initPower, communityTax)
+
+	ctx, ak, _, dk, sk, fck, _ := CreateTestInputAdvanced(t, isCheckTx, initPower, communityTax)
+	return ctx, ak, dk, sk, fck
 }
 
 // hogpodge of all sorts of input required for testing
 func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64,
-	communityTax sdk.Dec) (
-	sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, DummyFeeCollectionKeeper) {
+	communityTax sdk.Dec) (sdk.Context, auth.AccountKeeper, bank.Keeper,
+	Keeper, staking.Keeper, DummyFeeCollectionKeeper, params.Keeper) {
 
 	initCoins := sdk.TokensFromTendermintPower(initPower)
 
@@ -112,15 +115,15 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64,
 
 	ctx := sdk.NewContext(ms, abci.Header{ChainID: "foochainid"}, isCheckTx, log.NewNopLogger())
 	accountKeeper := auth.NewAccountKeeper(cdc, keyAcc, pk.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount)
-	ck := bank.NewBaseKeeper(accountKeeper, pk.Subspace(bank.DefaultParamspace), bank.DefaultCodespace)
-	sk := staking.NewKeeper(cdc, keyStaking, tkeyStaking, ck, pk.Subspace(staking.DefaultParamspace), staking.DefaultCodespace)
+	bankKeeper := bank.NewBaseKeeper(accountKeeper, pk.Subspace(bank.DefaultParamspace), bank.DefaultCodespace)
+	sk := staking.NewKeeper(cdc, keyStaking, tkeyStaking, bankKeeper, pk.Subspace(staking.DefaultParamspace), staking.DefaultCodespace)
 	sk.SetPool(ctx, staking.InitialPool())
 	sk.SetParams(ctx, staking.DefaultParams())
 
 	// fill all the addresses with some coins, set the loose pool tokens simultaneously
-	for _, addr := range addrs {
+	for _, addr := range TestAddrs {
 		pool := sk.GetPool(ctx)
-		_, _, err := ck.AddCoins(ctx, addr, sdk.Coins{
+		_, _, err := bankKeeper.AddCoins(ctx, addr, sdk.Coins{
 			sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins),
 		})
 		require.Nil(t, err)
@@ -129,7 +132,7 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64,
 	}
 
 	fck := DummyFeeCollectionKeeper{}
-	keeper := NewKeeper(cdc, keyDistr, pk.Subspace(DefaultParamspace), ck, sk, fck, types.DefaultCodespace)
+	keeper := NewKeeper(cdc, keyDistr, pk.Subspace(DefaultParamspace), bankKeeper, sk, fck, types.DefaultCodespace)
 
 	// set the distribution hooks on staking
 	sk.SetHooks(keeper.Hooks())
@@ -140,7 +143,7 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64,
 	keeper.SetBaseProposerReward(ctx, sdk.NewDecWithPrec(1, 2))
 	keeper.SetBonusProposerReward(ctx, sdk.NewDecWithPrec(4, 2))
 
-	return ctx, accountKeeper, keeper, sk, fck
+	return ctx, accountKeeper, bankKeeper, keeper, sk, fck, pk
 }
 
 //__________________________________________________________________________________
@@ -151,6 +154,10 @@ var heldFees sdk.Coins
 var _ types.FeeCollectionKeeper = DummyFeeCollectionKeeper{}
 
 // nolint
+func (fck DummyFeeCollectionKeeper) AddCollectedFees(_ sdk.Context, in sdk.Coins) sdk.Coins {
+	fck.SetCollectedFees(heldFees.Add(in))
+	return heldFees
+}
 func (fck DummyFeeCollectionKeeper) GetCollectedFees(_ sdk.Context) sdk.Coins {
 	return heldFees
 }
@@ -158,5 +165,5 @@ func (fck DummyFeeCollectionKeeper) SetCollectedFees(in sdk.Coins) {
 	heldFees = in
 }
 func (fck DummyFeeCollectionKeeper) ClearCollectedFees(_ sdk.Context) {
-	heldFees = sdk.Coins{}
+	heldFees = sdk.NewCoins()
 }
diff --git a/x/distribution/keeper/validator.go b/x/distribution/keeper/validator.go
index 18c6cc6e8..93c20f479 100644
--- a/x/distribution/keeper/validator.go
+++ b/x/distribution/keeper/validator.go
@@ -106,7 +106,10 @@ func (k Keeper) updateValidatorSlashFraction(ctx sdk.Context, valAddr sdk.ValAdd
 	}
 	currentMultiplicand := sdk.OneDec().Sub(currentFraction)
 	newMultiplicand := sdk.OneDec().Sub(fraction)
-	updatedFraction := sdk.OneDec().Sub(currentMultiplicand.Mul(newMultiplicand))
+
+	// using MulTruncate here conservatively increases the slashing amount
+	updatedFraction := sdk.OneDec().Sub(currentMultiplicand.MulTruncate(newMultiplicand))
+
 	if updatedFraction.LT(sdk.ZeroDec()) {
 		panic("negative slash fraction")
 	}
diff --git a/x/distribution/simulation/msgs.go b/x/distribution/simulation/msgs.go
index 9f979d86d..ba610343d 100644
--- a/x/distribution/simulation/msgs.go
+++ b/x/distribution/simulation/msgs.go
@@ -8,34 +8,31 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/distribution"
-	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
 )
 
 // SimulateMsgSetWithdrawAddress
 func SimulateMsgSetWithdrawAddress(m auth.AccountKeeper, k distribution.Keeper) simulation.Operation {
 	handler := distribution.NewHandler(k)
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		accountOrigin := simulation.RandomAcc(r, accs)
 		accountDestination := simulation.RandomAcc(r, accs)
 		msg := distribution.NewMsgSetWithdrawAddress(accountOrigin.Address, accountDestination.Address)
 
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 
 		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
+		ok := handler(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
 
-		event(fmt.Sprintf("distribution/MsgSetWithdrawAddress/%v", result.IsOK()))
-
-		action = fmt.Sprintf("TestMsgSetWithdrawAddress: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
@@ -43,27 +40,24 @@ func SimulateMsgSetWithdrawAddress(m auth.AccountKeeper, k distribution.Keeper)
 func SimulateMsgWithdrawDelegatorReward(m auth.AccountKeeper, k distribution.Keeper) simulation.Operation {
 	handler := distribution.NewHandler(k)
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		delegatorAccount := simulation.RandomAcc(r, accs)
 		validatorAccount := simulation.RandomAcc(r, accs)
 		msg := distribution.NewMsgWithdrawDelegatorReward(delegatorAccount.Address, sdk.ValAddress(validatorAccount.Address))
 
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 
 		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
+		ok := handler(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
 
-		event(fmt.Sprintf("distribution/MsgWithdrawDelegatorReward/%v", result.IsOK()))
-
-		action = fmt.Sprintf("TestMsgWithdrawDelegatorReward: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
@@ -71,25 +65,22 @@ func SimulateMsgWithdrawDelegatorReward(m auth.AccountKeeper, k distribution.Kee
 func SimulateMsgWithdrawValidatorCommission(m auth.AccountKeeper, k distribution.Keeper) simulation.Operation {
 	handler := distribution.NewHandler(k)
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		account := simulation.RandomAcc(r, accs)
 		msg := distribution.NewMsgWithdrawValidatorCommission(sdk.ValAddress(account.Address))
 
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 
 		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
+		ok := handler(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
 
-		event(fmt.Sprintf("distribution/MsgWithdrawValidatorCommission/%v", result.IsOK()))
-
-		action = fmt.Sprintf("TestMsgWithdrawValidatorCommission: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
diff --git a/x/distribution/types/errors.go b/x/distribution/types/errors.go
index 907ad226e..dfe988ff3 100644
--- a/x/distribution/types/errors.go
+++ b/x/distribution/types/errors.go
@@ -8,7 +8,7 @@ import (
 type CodeType = sdk.CodeType
 
 const (
-	DefaultCodespace            sdk.CodespaceType = "DISTR"
+	DefaultCodespace            sdk.CodespaceType = "distr"
 	CodeInvalidInput            CodeType          = 103
 	CodeNoDistributionInfo      CodeType          = 104
 	CodeNoValidatorCommission   CodeType          = 105
@@ -36,3 +36,6 @@ func ErrNoValidatorCommission(codespace sdk.CodespaceType) sdk.Error {
 func ErrSetWithdrawAddrDisabled(codespace sdk.CodespaceType) sdk.Error {
 	return sdk.NewError(codespace, CodeSetWithdrawAddrDisabled, "set withdraw address disabled")
 }
+func ErrBadDistribution(codespace sdk.CodespaceType) sdk.Error {
+	return sdk.NewError(codespace, CodeInvalidInput, "community pool does not have sufficient coins to distribute")
+}
diff --git a/x/distribution/types/expected_keepers.go b/x/distribution/types/expected_keepers.go
index eef0daa54..4c0961329 100644
--- a/x/distribution/types/expected_keepers.go
+++ b/x/distribution/types/expected_keepers.go
@@ -28,3 +28,8 @@ type FeeCollectionKeeper interface {
 	GetCollectedFees(ctx sdk.Context) sdk.Coins
 	ClearCollectedFees(ctx sdk.Context)
 }
+
+// expected crisis keeper
+type CrisisKeeper interface {
+	RegisterRoute(moduleName, route string, invar sdk.Invariant)
+}
diff --git a/x/distribution/types/keys.go b/x/distribution/types/keys.go
index 7bd90425d..21d182acb 100644
--- a/x/distribution/types/keys.go
+++ b/x/distribution/types/keys.go
@@ -1,15 +1,18 @@
 package types
 
 const (
+	// ModuleName is the module name constant used in many places
+	ModuleName = "distr"
+
 	// StoreKey is the store key string for distribution
-	StoreKey = "distr"
+	StoreKey = ModuleName
 
 	// TStoreKey is the transient store key for distribution
-	TStoreKey = "transient_distr"
+	TStoreKey = "transient_" + ModuleName
 
 	// RouterKey is the message route for distribution
-	RouterKey = "distr"
+	RouterKey = ModuleName
 
 	// QuerierRoute is the querier route for distribution
-	QuerierRoute = "distr"
+	QuerierRoute = ModuleName
 )
diff --git a/x/distribution/types/msg.go b/x/distribution/types/msg.go
index 30f170f03..2f773d473 100644
--- a/x/distribution/types/msg.go
+++ b/x/distribution/types/msg.go
@@ -5,9 +5,6 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-// name to identify transaction types
-const MsgRoute = "distr"
-
 // Verify interface at compile time
 var _, _, _ sdk.Msg = &MsgSetWithdrawAddress{}, &MsgWithdrawDelegatorReward{}, &MsgWithdrawValidatorCommission{}
 
@@ -24,7 +21,7 @@ func NewMsgSetWithdrawAddress(delAddr, withdrawAddr sdk.AccAddress) MsgSetWithdr
 	}
 }
 
-func (msg MsgSetWithdrawAddress) Route() string { return MsgRoute }
+func (msg MsgSetWithdrawAddress) Route() string { return ModuleName }
 func (msg MsgSetWithdrawAddress) Type() string  { return "set_withdraw_address" }
 
 // Return address that must sign over msg.GetSignBytes()
@@ -62,7 +59,7 @@ func NewMsgWithdrawDelegatorReward(delAddr sdk.AccAddress, valAddr sdk.ValAddres
 	}
 }
 
-func (msg MsgWithdrawDelegatorReward) Route() string { return MsgRoute }
+func (msg MsgWithdrawDelegatorReward) Route() string { return ModuleName }
 func (msg MsgWithdrawDelegatorReward) Type() string  { return "withdraw_delegator_reward" }
 
 // Return address that must sign over msg.GetSignBytes()
@@ -98,7 +95,7 @@ func NewMsgWithdrawValidatorCommission(valAddr sdk.ValAddress) MsgWithdrawValida
 	}
 }
 
-func (msg MsgWithdrawValidatorCommission) Route() string { return MsgRoute }
+func (msg MsgWithdrawValidatorCommission) Route() string { return ModuleName }
 func (msg MsgWithdrawValidatorCommission) Type() string  { return "withdraw_validator_rewards_all" }
 
 // Return address that must sign over msg.GetSignBytes()
diff --git a/x/gov/client/cli/query.go b/x/gov/client/cli/query.go
index 4d2b8ddde..9aa52383d 100644
--- a/x/gov/client/cli/query.go
+++ b/x/gov/client/cli/query.go
@@ -43,7 +43,7 @@ $ gaiacli query gov proposal 1
 
 			var proposal gov.Proposal
 			cdc.MustUnmarshalJSON(res, &proposal)
-			return cliCtx.PrintOutput(proposal)
+			return cliCtx.PrintOutput(proposal) // nolint:errcheck
 		},
 	}
 }
@@ -118,7 +118,7 @@ $ gaiacli query gov proposals --status (DepositPeriod|VotingPeriod|Passed|Reject
 				return fmt.Errorf("No matching proposals found")
 			}
 
-			return cliCtx.PrintOutput(matchingProposals)
+			return cliCtx.PrintOutput(matchingProposals) // nolint:errcheck
 		},
 	}
 
@@ -175,17 +175,21 @@ $ gaiacli query gov vote 1 cosmos1skjwj5whet0lpe65qaq4rpq03hjxlwd9nf39lk
 			}
 
 			var vote gov.Vote
-			cdc.UnmarshalJSON(res, &vote)
+			if err := cdc.UnmarshalJSON(res, &vote); err != nil {
+				return err
+			}
 
 			if vote.Empty() {
 				res, err = gcutils.QueryVoteByTxQuery(cdc, cliCtx, params)
 				if err != nil {
 					return err
 				}
-				cdc.UnmarshalJSON(res, &vote)
+				if err := cdc.UnmarshalJSON(res, &vote); err != nil {
+					return err
+				}
 			}
 
-			return cliCtx.PrintOutput(vote)
+			return cliCtx.PrintOutput(vote) //nolint:errcheck
 		},
 	}
 }
@@ -226,7 +230,7 @@ $ gaiacli query gov votes 1
 			var proposal gov.Proposal
 			cdc.MustUnmarshalJSON(res, &proposal)
 
-			propStatus := proposal.GetStatus()
+			propStatus := proposal.Status
 			if !(propStatus == gov.StatusVotingPeriod || propStatus == gov.StatusDepositPeriod) {
 				res, err = gcutils.QueryVotesByTxQuery(cdc, cliCtx, params)
 			} else {
@@ -339,7 +343,7 @@ $ gaiacli query gov deposits 1
 			var proposal gov.Proposal
 			cdc.MustUnmarshalJSON(res, &proposal)
 
-			propStatus := proposal.GetStatus()
+			propStatus := proposal.Status
 			if !(propStatus == gov.StatusVotingPeriod || propStatus == gov.StatusDepositPeriod) {
 				res, err = gcutils.QueryDepositsByTxQuery(cdc, cliCtx, params)
 			} else {
diff --git a/x/gov/client/rest/rest.go b/x/gov/client/rest/rest.go
index 5bfd676a9..ebd3362aa 100644
--- a/x/gov/client/rest/rest.go
+++ b/x/gov/client/rest/rest.go
@@ -266,7 +266,7 @@ func queryDepositsHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.Ha
 
 		// For inactive proposals we must query the txs directly to get the deposits
 		// as they're no longer in state.
-		propStatus := proposal.GetStatus()
+		propStatus := proposal.Status
 		if !(propStatus == gov.StatusVotingPeriod || propStatus == gov.StatusDepositPeriod) {
 			res, err = gcutils.QueryDepositsByTxQuery(cdc, cliCtx, params)
 		} else {
@@ -346,7 +346,10 @@ func queryDepositHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.Han
 		}
 
 		var deposit gov.Deposit
-		cdc.UnmarshalJSON(res, &deposit)
+		if err := cdc.UnmarshalJSON(res, &deposit); err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
 
 		// For an empty deposit, either the proposal does not exist or is inactive in
 		// which case the deposit would be removed from state and should be queried
@@ -420,7 +423,10 @@ func queryVoteHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.Handle
 		}
 
 		var vote gov.Vote
-		cdc.UnmarshalJSON(res, &vote)
+		if err := cdc.UnmarshalJSON(res, &vote); err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
 
 		// For an empty vote, either the proposal does not exist or is inactive in
 		// which case the vote would be removed from state and should be queried for
@@ -489,7 +495,7 @@ func queryVotesOnProposalHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext)
 
 		// For inactive proposals we must query the txs directly to get the votes
 		// as they're no longer in state.
-		propStatus := proposal.GetStatus()
+		propStatus := proposal.Status
 		if !(propStatus == gov.StatusVotingPeriod || propStatus == gov.StatusDepositPeriod) {
 			res, err = gcutils.QueryVotesByTxQuery(cdc, cliCtx, params)
 		} else {
diff --git a/x/gov/codec.go b/x/gov/codec.go
index 10fecb3bc..44167711d 100644
--- a/x/gov/codec.go
+++ b/x/gov/codec.go
@@ -12,8 +12,9 @@ func RegisterCodec(cdc *codec.Codec) {
 	cdc.RegisterConcrete(MsgDeposit{}, "cosmos-sdk/MsgDeposit", nil)
 	cdc.RegisterConcrete(MsgVote{}, "cosmos-sdk/MsgVote", nil)
 
-	cdc.RegisterInterface((*Proposal)(nil), nil)
-	cdc.RegisterConcrete(&TextProposal{}, "gov/TextProposal", nil)
+	cdc.RegisterInterface((*ProposalContent)(nil), nil)
+	cdc.RegisterConcrete(TextProposal{}, "gov/TextProposal", nil)
+	cdc.RegisterConcrete(SoftwareUpgradeProposal{}, "gov/SoftwareUpgradeProposal", nil)
 }
 
 func init() {
diff --git a/x/gov/endblocker.go b/x/gov/endblocker.go
index 294a0e44f..3da7f3a1d 100644
--- a/x/gov/endblocker.go
+++ b/x/gov/endblocker.go
@@ -18,7 +18,10 @@ func EndBlocker(ctx sdk.Context, keeper Keeper) sdk.Tags {
 		var proposalID uint64
 
 		keeper.cdc.MustUnmarshalBinaryLengthPrefixed(inactiveIterator.Value(), &proposalID)
-		inactiveProposal := keeper.GetProposal(ctx, proposalID)
+		inactiveProposal, ok := keeper.GetProposal(ctx, proposalID)
+		if !ok {
+			panic(fmt.Sprintf("proposal %d does not exist", proposalID))
+		}
 
 		keeper.DeleteProposal(ctx, proposalID)
 		keeper.DeleteDeposits(ctx, proposalID) // delete any associated deposits (burned)
@@ -28,10 +31,10 @@ func EndBlocker(ctx sdk.Context, keeper Keeper) sdk.Tags {
 
 		logger.Info(
 			fmt.Sprintf("proposal %d (%s) didn't meet minimum deposit of %s (had only %s); deleted",
-				inactiveProposal.GetProposalID(),
+				inactiveProposal.ProposalID,
 				inactiveProposal.GetTitle(),
 				keeper.GetDepositParams(ctx).MinDeposit,
-				inactiveProposal.GetTotalDeposit(),
+				inactiveProposal.TotalDeposit,
 			),
 		)
 	}
@@ -43,28 +46,31 @@ func EndBlocker(ctx sdk.Context, keeper Keeper) sdk.Tags {
 		var proposalID uint64
 
 		keeper.cdc.MustUnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID)
-		activeProposal := keeper.GetProposal(ctx, proposalID)
+		activeProposal, ok := keeper.GetProposal(ctx, proposalID)
+		if !ok {
+			panic(fmt.Sprintf("proposal %d does not exist", proposalID))
+		}
 		passes, tallyResults := tally(ctx, keeper, activeProposal)
 
 		var tagValue string
 		if passes {
-			keeper.RefundDeposits(ctx, activeProposal.GetProposalID())
-			activeProposal.SetStatus(StatusPassed)
+			keeper.RefundDeposits(ctx, activeProposal.ProposalID)
+			activeProposal.Status = StatusPassed
 			tagValue = tags.ActionProposalPassed
 		} else {
-			keeper.DeleteDeposits(ctx, activeProposal.GetProposalID())
-			activeProposal.SetStatus(StatusRejected)
+			keeper.DeleteDeposits(ctx, activeProposal.ProposalID)
+			activeProposal.Status = StatusRejected
 			tagValue = tags.ActionProposalRejected
 		}
 
-		activeProposal.SetFinalTallyResult(tallyResults)
+		activeProposal.FinalTallyResult = tallyResults
 		keeper.SetProposal(ctx, activeProposal)
-		keeper.RemoveFromActiveProposalQueue(ctx, activeProposal.GetVotingEndTime(), activeProposal.GetProposalID())
+		keeper.RemoveFromActiveProposalQueue(ctx, activeProposal.VotingEndTime, activeProposal.ProposalID)
 
 		logger.Info(
 			fmt.Sprintf(
 				"proposal %d (%s) tallied; passed: %v",
-				activeProposal.GetProposalID(), activeProposal.GetTitle(), passes,
+				activeProposal.ProposalID, activeProposal.GetTitle(), passes,
 			),
 		)
 
diff --git a/x/gov/endblocker_test.go b/x/gov/endblocker_test.go
index d4847b764..86e9a4ef2 100644
--- a/x/gov/endblocker_test.go
+++ b/x/gov/endblocker_test.go
@@ -13,7 +13,10 @@ import (
 
 func TestTickExpiredDepositPeriod(t *testing.T) {
 	mapp, keeper, _, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	keeper.ck.SetSendEnabled(ctx, true)
 	govHandler := NewHandler(keeper)
@@ -56,7 +59,10 @@ func TestTickExpiredDepositPeriod(t *testing.T) {
 
 func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
 	mapp, keeper, _, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	keeper.ck.SetSendEnabled(ctx, true)
 	govHandler := NewHandler(keeper)
@@ -113,7 +119,10 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
 
 func TestTickPassedDepositPeriod(t *testing.T) {
 	mapp, keeper, _, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	keeper.ck.SetSendEnabled(ctx, true)
 	govHandler := NewHandler(keeper)
@@ -156,7 +165,10 @@ func TestTickPassedDepositPeriod(t *testing.T) {
 func TestTickPassedVotingPeriod(t *testing.T) {
 	mapp, keeper, _, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
 	SortAddresses(addrs)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	keeper.ck.SetSendEnabled(ctx, true)
 	govHandler := NewHandler(keeper)
@@ -196,7 +208,9 @@ func TestTickPassedVotingPeriod(t *testing.T) {
 	require.True(t, activeQueue.Valid())
 	var activeProposalID uint64
 	keeper.cdc.UnmarshalBinaryLengthPrefixed(activeQueue.Value(), &activeProposalID)
-	require.Equal(t, StatusVotingPeriod, keeper.GetProposal(ctx, activeProposalID).GetStatus())
+	proposal, ok := keeper.GetProposal(ctx, activeProposalID)
+	require.True(t, ok)
+	require.Equal(t, StatusVotingPeriod, proposal.Status)
 	depositsIterator := keeper.GetDeposits(ctx, proposalID)
 	require.True(t, depositsIterator.Valid())
 	depositsIterator.Close()
diff --git a/x/gov/genesis.go b/x/gov/genesis.go
index 6426f30df..4aeb9d862 100644
--- a/x/gov/genesis.go
+++ b/x/gov/genesis.go
@@ -92,11 +92,6 @@ func ValidateGenesis(data GenesisState) error {
 			veto.String())
 	}
 
-	if data.DepositParams.MaxDepositPeriod > data.VotingParams.VotingPeriod {
-		return fmt.Errorf("Governance deposit period should be less than or equal to the voting period (%ds), is %ds",
-			data.VotingParams.VotingPeriod, data.DepositParams.MaxDepositPeriod)
-	}
-
 	if !data.DepositParams.MinDeposit.IsValid() {
 		return fmt.Errorf("Governance deposit amount must be a valid sdk.Coins amount, is %s",
 			data.DepositParams.MinDeposit.String())
@@ -122,11 +117,11 @@ func InitGenesis(ctx sdk.Context, k Keeper, data GenesisState) {
 		k.setVote(ctx, vote.ProposalID, vote.Vote.Voter, vote.Vote)
 	}
 	for _, proposal := range data.Proposals {
-		switch proposal.GetStatus() {
+		switch proposal.Status {
 		case StatusDepositPeriod:
-			k.InsertInactiveProposalQueue(ctx, proposal.GetDepositEndTime(), proposal.GetProposalID())
+			k.InsertInactiveProposalQueue(ctx, proposal.DepositEndTime, proposal.ProposalID)
 		case StatusVotingPeriod:
-			k.InsertActiveProposalQueue(ctx, proposal.GetVotingEndTime(), proposal.GetProposalID())
+			k.InsertActiveProposalQueue(ctx, proposal.VotingEndTime, proposal.ProposalID)
 		}
 		k.SetProposal(ctx, proposal)
 	}
@@ -142,7 +137,7 @@ func ExportGenesis(ctx sdk.Context, k Keeper) GenesisState {
 	var votes []VoteWithMetadata
 	proposals := k.GetProposalsFiltered(ctx, nil, nil, StatusNil, 0)
 	for _, proposal := range proposals {
-		proposalID := proposal.GetProposalID()
+		proposalID := proposal.ProposalID
 		depositsIterator := k.GetDeposits(ctx, proposalID)
 		defer depositsIterator.Close()
 		for ; depositsIterator.Valid(); depositsIterator.Next() {
diff --git a/x/gov/genesis_test.go b/x/gov/genesis_test.go
index 5624c58ae..599cf8949 100644
--- a/x/gov/genesis_test.go
+++ b/x/gov/genesis_test.go
@@ -27,12 +27,18 @@ func TestEqualProposals(t *testing.T) {
 	// Generate mock app and keepers
 	mapp, keeper, _, addrs, _, _ := getMockApp(t, 2, GenesisState{}, nil)
 	SortAddresses(addrs)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 
-	// Create two proposals
-	proposal1 := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposal2 := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
+	// Submit two proposals
+	proposal := testProposal()
+	proposal1, err := keeper.SubmitProposal(ctx, proposal)
+	require.NoError(t, err)
+	proposal2, err := keeper.SubmitProposal(ctx, proposal)
+	require.NoError(t, err)
 
 	// They are similar but their IDs should be different
 	require.NotEqual(t, proposal1, proposal2)
@@ -45,36 +51,49 @@ func TestEqualProposals(t *testing.T) {
 	require.False(t, state1.Equal(state2))
 
 	// Now make proposals identical by setting both IDs to 55
-	proposal1.SetProposalID(55)
-	proposal2.SetProposalID(55)
+	proposal1.ProposalID = 55
+	proposal2.ProposalID = 55
 	require.Equal(t, proposal1, proposal1)
 	require.True(t, ProposalEqual(proposal1, proposal2))
 
+	// Reassign proposals into state
+	state1.Proposals[0] = proposal1
+	state2.Proposals[0] = proposal2
+
 	// State should be identical now..
 	require.Equal(t, state1, state2)
 	require.True(t, state1.Equal(state2))
 }
 
 func TestImportExportQueues(t *testing.T) {
-
 	// Generate mock app and keepers
 	mapp, keeper, _, addrs, _, _ := getMockApp(t, 2, GenesisState{}, nil)
 	SortAddresses(addrs)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 
 	// Create two proposals, put the second into the voting period
-	proposal1 := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID1 := proposal1.GetProposalID()
+	proposal := testProposal()
+	proposal1, err := keeper.SubmitProposal(ctx, proposal)
+	require.NoError(t, err)
+	proposalID1 := proposal1.ProposalID
 
-	proposal2 := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID2 := proposal2.GetProposalID()
+	proposal2, err := keeper.SubmitProposal(ctx, proposal)
+	require.NoError(t, err)
+	proposalID2 := proposal2.ProposalID
 
 	_, votingStarted := keeper.AddDeposit(ctx, proposalID2, addrs[0], keeper.GetDepositParams(ctx).MinDeposit)
 	require.True(t, votingStarted)
 
-	require.True(t, keeper.GetProposal(ctx, proposalID1).GetStatus() == StatusDepositPeriod)
-	require.True(t, keeper.GetProposal(ctx, proposalID2).GetStatus() == StatusVotingPeriod)
+	proposal1, ok := keeper.GetProposal(ctx, proposalID1)
+	require.True(t, ok)
+	proposal2, ok = keeper.GetProposal(ctx, proposalID2)
+	require.True(t, ok)
+	require.True(t, proposal1.Status == StatusDepositPeriod)
+	require.True(t, proposal2.Status == StatusVotingPeriod)
 
 	genAccs := mapp.AccountKeeper.GetAllAccounts(ctx)
 
@@ -82,19 +101,28 @@ func TestImportExportQueues(t *testing.T) {
 	genState := ExportGenesis(ctx, keeper)
 	mapp2, keeper2, _, _, _, _ := getMockApp(t, 2, genState, genAccs)
 
-	mapp2.BeginBlock(abci.RequestBeginBlock{})
+	header = abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp2.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx2 := mapp2.BaseApp.NewContext(false, abci.Header{})
 
 	// Jump the time forward past the DepositPeriod and VotingPeriod
 	ctx2 = ctx2.WithBlockTime(ctx2.BlockHeader().Time.Add(keeper2.GetDepositParams(ctx2).MaxDepositPeriod).Add(keeper2.GetVotingParams(ctx2).VotingPeriod))
 
 	// Make sure that they are still in the DepositPeriod and VotingPeriod respectively
-	require.True(t, keeper2.GetProposal(ctx2, proposalID1).GetStatus() == StatusDepositPeriod)
-	require.True(t, keeper2.GetProposal(ctx2, proposalID2).GetStatus() == StatusVotingPeriod)
+	proposal1, ok = keeper2.GetProposal(ctx2, proposalID1)
+	require.True(t, ok)
+	proposal2, ok = keeper2.GetProposal(ctx2, proposalID2)
+	require.True(t, ok)
+	require.True(t, proposal1.Status == StatusDepositPeriod)
+	require.True(t, proposal2.Status == StatusVotingPeriod)
 
 	// Run the endblocker.  Check to make sure that proposal1 is removed from state, and proposal2 is finished VotingPeriod.
 	EndBlocker(ctx2, keeper2)
 
-	require.Nil(t, keeper2.GetProposal(ctx2, proposalID1))
-	require.True(t, keeper2.GetProposal(ctx2, proposalID2).GetStatus() == StatusRejected)
+	proposal1, ok = keeper2.GetProposal(ctx2, proposalID1)
+	require.False(t, ok)
+	proposal2, ok = keeper2.GetProposal(ctx2, proposalID2)
+	require.True(t, ok)
+	require.True(t, proposal2.Status == StatusRejected)
 }
diff --git a/x/gov/handler.go b/x/gov/handler.go
index 133ea541b..e51f11895 100644
--- a/x/gov/handler.go
+++ b/x/gov/handler.go
@@ -25,8 +25,20 @@ func NewHandler(keeper Keeper) sdk.Handler {
 }
 
 func handleMsgSubmitProposal(ctx sdk.Context, keeper Keeper, msg MsgSubmitProposal) sdk.Result {
-	proposal := keeper.NewTextProposal(ctx, msg.Title, msg.Description, msg.ProposalType)
-	proposalID := proposal.GetProposalID()
+	var content ProposalContent
+	switch msg.ProposalType {
+	case ProposalTypeText:
+		content = NewTextProposal(msg.Title, msg.Description)
+	case ProposalTypeSoftwareUpgrade:
+		content = NewSoftwareUpgradeProposal(msg.Title, msg.Description)
+	default:
+		return ErrInvalidProposalType(keeper.codespace, msg.ProposalType).Result()
+	}
+	proposal, err := keeper.SubmitProposal(ctx, content)
+	if err != nil {
+		return err.Result()
+	}
+	proposalID := proposal.ProposalID
 	proposalIDStr := fmt.Sprintf("%d", proposalID)
 
 	err, votingStarted := keeper.AddDeposit(ctx, proposalID, msg.Proposer, msg.InitialDeposit)
diff --git a/x/gov/keeper.go b/x/gov/keeper.go
index 2ea507977..46085cf2d 100644
--- a/x/gov/keeper.go
+++ b/x/gov/keeper.go
@@ -95,57 +95,58 @@ func NewKeeper(cdc *codec.Codec, key sdk.StoreKey, paramsKeeper params.Keeper,
 }
 
 // Proposals
-
-// Creates a NewProposal
-func (keeper Keeper) NewTextProposal(ctx sdk.Context, title string, description string, proposalType ProposalKind) Proposal {
+func (keeper Keeper) SubmitProposal(ctx sdk.Context, content ProposalContent) (proposal Proposal, err sdk.Error) {
 	proposalID, err := keeper.getNewProposalID(ctx)
 	if err != nil {
-		return nil
+		return
 	}
-	var proposal Proposal = &TextProposal{
-		ProposalID:       proposalID,
-		Title:            title,
-		Description:      description,
-		ProposalType:     proposalType,
+
+	submitTime := ctx.BlockHeader().Time
+	depositPeriod := keeper.GetDepositParams(ctx).MaxDepositPeriod
+
+	proposal = Proposal{
+		ProposalContent: content,
+		ProposalID:      proposalID,
+
 		Status:           StatusDepositPeriod,
 		FinalTallyResult: EmptyTallyResult(),
-		TotalDeposit:     sdk.Coins{},
-		SubmitTime:       ctx.BlockHeader().Time,
+		TotalDeposit:     sdk.NewCoins(),
+		SubmitTime:       submitTime,
+		DepositEndTime:   submitTime.Add(depositPeriod),
 	}
 
-	depositPeriod := keeper.GetDepositParams(ctx).MaxDepositPeriod
-	proposal.SetDepositEndTime(proposal.GetSubmitTime().Add(depositPeriod))
-
 	keeper.SetProposal(ctx, proposal)
-	keeper.InsertInactiveProposalQueue(ctx, proposal.GetDepositEndTime(), proposalID)
-	return proposal
+	keeper.InsertInactiveProposalQueue(ctx, proposal.DepositEndTime, proposalID)
+	return
 }
 
 // Get Proposal from store by ProposalID
-func (keeper Keeper) GetProposal(ctx sdk.Context, proposalID uint64) Proposal {
+func (keeper Keeper) GetProposal(ctx sdk.Context, proposalID uint64) (proposal Proposal, ok bool) {
 	store := ctx.KVStore(keeper.storeKey)
 	bz := store.Get(KeyProposal(proposalID))
 	if bz == nil {
-		return nil
+		return
 	}
-	var proposal Proposal
 	keeper.cdc.MustUnmarshalBinaryLengthPrefixed(bz, &proposal)
-	return proposal
+	return proposal, true
 }
 
 // Implements sdk.AccountKeeper.
 func (keeper Keeper) SetProposal(ctx sdk.Context, proposal Proposal) {
 	store := ctx.KVStore(keeper.storeKey)
 	bz := keeper.cdc.MustMarshalBinaryLengthPrefixed(proposal)
-	store.Set(KeyProposal(proposal.GetProposalID()), bz)
+	store.Set(KeyProposal(proposal.ProposalID), bz)
 }
 
 // Implements sdk.AccountKeeper.
 func (keeper Keeper) DeleteProposal(ctx sdk.Context, proposalID uint64) {
 	store := ctx.KVStore(keeper.storeKey)
-	proposal := keeper.GetProposal(ctx, proposalID)
-	keeper.RemoveFromInactiveProposalQueue(ctx, proposal.GetDepositEndTime(), proposalID)
-	keeper.RemoveFromActiveProposalQueue(ctx, proposal.GetVotingEndTime(), proposalID)
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	if !ok {
+		panic("DeleteProposal cannot fail to GetProposal")
+	}
+	keeper.RemoveFromInactiveProposalQueue(ctx, proposal.DepositEndTime, proposalID)
+	keeper.RemoveFromActiveProposalQueue(ctx, proposal.VotingEndTime, proposalID)
 	store.Delete(KeyProposal(proposalID))
 }
 
@@ -182,13 +183,13 @@ func (keeper Keeper) GetProposalsFiltered(ctx sdk.Context, voterAddr sdk.AccAddr
 			}
 		}
 
-		proposal := keeper.GetProposal(ctx, proposalID)
-		if proposal == nil {
+		proposal, ok := keeper.GetProposal(ctx, proposalID)
+		if !ok {
 			continue
 		}
 
 		if validProposalStatus(status) {
-			if proposal.GetStatus() != status {
+			if proposal.Status != status {
 				continue
 			}
 		}
@@ -245,14 +246,14 @@ func (keeper Keeper) peekCurrentProposalID(ctx sdk.Context) (proposalID uint64,
 }
 
 func (keeper Keeper) activateVotingPeriod(ctx sdk.Context, proposal Proposal) {
-	proposal.SetVotingStartTime(ctx.BlockHeader().Time)
+	proposal.VotingStartTime = ctx.BlockHeader().Time
 	votingPeriod := keeper.GetVotingParams(ctx).VotingPeriod
-	proposal.SetVotingEndTime(proposal.GetVotingStartTime().Add(votingPeriod))
-	proposal.SetStatus(StatusVotingPeriod)
+	proposal.VotingEndTime = proposal.VotingStartTime.Add(votingPeriod)
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	keeper.RemoveFromInactiveProposalQueue(ctx, proposal.GetDepositEndTime(), proposal.GetProposalID())
-	keeper.InsertActiveProposalQueue(ctx, proposal.GetVotingEndTime(), proposal.GetProposalID())
+	keeper.RemoveFromInactiveProposalQueue(ctx, proposal.DepositEndTime, proposal.ProposalID)
+	keeper.InsertActiveProposalQueue(ctx, proposal.VotingEndTime, proposal.ProposalID)
 }
 
 // Params
@@ -294,11 +295,11 @@ func (keeper Keeper) setTallyParams(ctx sdk.Context, tallyParams TallyParams) {
 
 // Adds a vote on a specific proposal
 func (keeper Keeper) AddVote(ctx sdk.Context, proposalID uint64, voterAddr sdk.AccAddress, option VoteOption) sdk.Error {
-	proposal := keeper.GetProposal(ctx, proposalID)
-	if proposal == nil {
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	if !ok {
 		return ErrUnknownProposal(keeper.codespace, proposalID)
 	}
-	if proposal.GetStatus() != StatusVotingPeriod {
+	if proposal.Status != StatusVotingPeriod {
 		return ErrInactiveProposal(keeper.codespace, proposalID)
 	}
 
@@ -369,13 +370,13 @@ func (keeper Keeper) setDeposit(ctx sdk.Context, proposalID uint64, depositorAdd
 // Activates voting period when appropriate
 func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID uint64, depositorAddr sdk.AccAddress, depositAmount sdk.Coins) (sdk.Error, bool) {
 	// Checks to see if proposal exists
-	proposal := keeper.GetProposal(ctx, proposalID)
-	if proposal == nil {
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	if !ok {
 		return ErrUnknownProposal(keeper.codespace, proposalID), false
 	}
 
 	// Check if proposal is still depositable
-	if (proposal.GetStatus() != StatusDepositPeriod) && (proposal.GetStatus() != StatusVotingPeriod) {
+	if (proposal.Status != StatusDepositPeriod) && (proposal.Status != StatusVotingPeriod) {
 		return ErrAlreadyFinishedProposal(keeper.codespace, proposalID), false
 	}
 
@@ -387,12 +388,12 @@ func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID uint64, depositorAdd
 	}
 
 	// Update proposal
-	proposal.SetTotalDeposit(proposal.GetTotalDeposit().Add(depositAmount))
+	proposal.TotalDeposit = proposal.TotalDeposit.Add(depositAmount)
 	keeper.SetProposal(ctx, proposal)
 
 	// Check if deposit has provided sufficient total funds to transition the proposal into the voting period
 	activatedVotingPeriod := false
-	if proposal.GetStatus() == StatusDepositPeriod && proposal.GetTotalDeposit().IsAllGTE(keeper.GetDepositParams(ctx).MinDeposit) {
+	if proposal.Status == StatusDepositPeriod && proposal.TotalDeposit.IsAllGTE(keeper.GetDepositParams(ctx).MinDeposit) {
 		keeper.activateVotingPeriod(ctx, proposal)
 		activatedVotingPeriod = true
 	}
diff --git a/x/gov/keeper_test.go b/x/gov/keeper_test.go
index 44861877d..67905fd2d 100644
--- a/x/gov/keeper_test.go
+++ b/x/gov/keeper_test.go
@@ -13,123 +13,157 @@ import (
 
 func TestGetSetProposal(t *testing.T) {
 	mapp, keeper, _, _, _, _ := getMockApp(t, 0, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
+	tp := testProposal()
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
 	keeper.SetProposal(ctx, proposal)
 
-	gotProposal := keeper.GetProposal(ctx, proposalID)
+	gotProposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
 	require.True(t, ProposalEqual(proposal, gotProposal))
 }
 
 func TestIncrementProposalNumber(t *testing.T) {
 	mapp, keeper, _, _, _, _ := getMockApp(t, 0, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 
-	keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposal6 := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
+	tp := testProposal()
+	keeper.SubmitProposal(ctx, tp)
+	keeper.SubmitProposal(ctx, tp)
+	keeper.SubmitProposal(ctx, tp)
+	keeper.SubmitProposal(ctx, tp)
+	keeper.SubmitProposal(ctx, tp)
+	proposal6, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
 
-	require.Equal(t, uint64(6), proposal6.GetProposalID())
+	require.Equal(t, uint64(6), proposal6.ProposalID)
 }
 
 func TestActivateVotingPeriod(t *testing.T) {
 	mapp, keeper, _, _, _, _ := getMockApp(t, 0, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
+	tp := testProposal()
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
 
-	require.True(t, proposal.GetVotingStartTime().Equal(time.Time{}))
+	require.True(t, proposal.VotingStartTime.Equal(time.Time{}))
 
 	keeper.activateVotingPeriod(ctx, proposal)
 
-	require.True(t, proposal.GetVotingStartTime().Equal(ctx.BlockHeader().Time))
+	require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time))
 
-	activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.GetVotingEndTime())
+	proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID)
+	require.True(t, ok)
+
+	activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime)
 	require.True(t, activeIterator.Valid())
 	var proposalID uint64
 	keeper.cdc.UnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID)
-	require.Equal(t, proposalID, proposal.GetProposalID())
+	require.Equal(t, proposalID, proposal.ProposalID)
 	activeIterator.Close()
 }
 
 func TestDeposits(t *testing.T) {
 	mapp, keeper, _, addrs, _, _ := getMockApp(t, 2, GenesisState{}, nil)
 	SortAddresses(addrs)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
+	tp := testProposal()
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
 
-	fourSteak := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(4))}
-	fiveSteak := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(5))}
+	fourStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(4)))
+	fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(5)))
 
 	addr0Initial := keeper.ck.GetCoins(ctx, addrs[0])
 	addr1Initial := keeper.ck.GetCoins(ctx, addrs[1])
 
 	expTokens := sdk.TokensFromTendermintPower(42)
-	require.Equal(t, sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, expTokens)}, addr0Initial)
-	require.True(t, proposal.GetTotalDeposit().IsEqual(sdk.Coins{}))
+	require.Equal(t, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, expTokens)), addr0Initial)
+	require.True(t, proposal.TotalDeposit.IsEqual(sdk.NewCoins()))
 
 	// Check no deposits at beginning
 	deposit, found := keeper.GetDeposit(ctx, proposalID, addrs[1])
 	require.False(t, found)
-	require.True(t, keeper.GetProposal(ctx, proposalID).GetVotingStartTime().Equal(time.Time{}))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	require.True(t, proposal.VotingStartTime.Equal(time.Time{}))
 
 	// Check first deposit
-	err, votingStarted := keeper.AddDeposit(ctx, proposalID, addrs[0], fourSteak)
+	err, votingStarted := keeper.AddDeposit(ctx, proposalID, addrs[0], fourStake)
 	require.Nil(t, err)
 	require.False(t, votingStarted)
 	deposit, found = keeper.GetDeposit(ctx, proposalID, addrs[0])
 	require.True(t, found)
-	require.Equal(t, fourSteak, deposit.Amount)
+	require.Equal(t, fourStake, deposit.Amount)
 	require.Equal(t, addrs[0], deposit.Depositor)
-	require.Equal(t, fourSteak, keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
-	require.Equal(t, addr0Initial.Sub(fourSteak), keeper.ck.GetCoins(ctx, addrs[0]))
+	proposal, ok = keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	require.Equal(t, fourStake, proposal.TotalDeposit)
+	require.Equal(t, addr0Initial.Sub(fourStake), keeper.ck.GetCoins(ctx, addrs[0]))
 
 	// Check a second deposit from same address
-	err, votingStarted = keeper.AddDeposit(ctx, proposalID, addrs[0], fiveSteak)
+	err, votingStarted = keeper.AddDeposit(ctx, proposalID, addrs[0], fiveStake)
 	require.Nil(t, err)
 	require.False(t, votingStarted)
 	deposit, found = keeper.GetDeposit(ctx, proposalID, addrs[0])
 	require.True(t, found)
-	require.Equal(t, fourSteak.Add(fiveSteak), deposit.Amount)
+	require.Equal(t, fourStake.Add(fiveStake), deposit.Amount)
 	require.Equal(t, addrs[0], deposit.Depositor)
-	require.Equal(t, fourSteak.Add(fiveSteak), keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
-	require.Equal(t, addr0Initial.Sub(fourSteak).Sub(fiveSteak), keeper.ck.GetCoins(ctx, addrs[0]))
+	proposal, ok = keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	require.Equal(t, fourStake.Add(fiveStake), proposal.TotalDeposit)
+	require.Equal(t, addr0Initial.Sub(fourStake).Sub(fiveStake), keeper.ck.GetCoins(ctx, addrs[0]))
 
 	// Check third deposit from a new address
-	err, votingStarted = keeper.AddDeposit(ctx, proposalID, addrs[1], fourSteak)
+	err, votingStarted = keeper.AddDeposit(ctx, proposalID, addrs[1], fourStake)
 	require.Nil(t, err)
 	require.True(t, votingStarted)
 	deposit, found = keeper.GetDeposit(ctx, proposalID, addrs[1])
 	require.True(t, found)
 	require.Equal(t, addrs[1], deposit.Depositor)
-	require.Equal(t, fourSteak, deposit.Amount)
-	require.Equal(t, fourSteak.Add(fiveSteak).Add(fourSteak), keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
-	require.Equal(t, addr1Initial.Sub(fourSteak), keeper.ck.GetCoins(ctx, addrs[1]))
+	require.Equal(t, fourStake, deposit.Amount)
+	proposal, ok = keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	require.Equal(t, fourStake.Add(fiveStake).Add(fourStake), proposal.TotalDeposit)
+	require.Equal(t, addr1Initial.Sub(fourStake), keeper.ck.GetCoins(ctx, addrs[1]))
 
 	// Check that proposal moved to voting period
-	require.True(t, keeper.GetProposal(ctx, proposalID).GetVotingStartTime().Equal(ctx.BlockHeader().Time))
+	proposal, ok = keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	require.True(t, proposal.VotingStartTime.Equal(ctx.BlockHeader().Time))
 
 	// Test deposit iterator
 	depositsIterator := keeper.GetDeposits(ctx, proposalID)
 	require.True(t, depositsIterator.Valid())
 	keeper.cdc.MustUnmarshalBinaryLengthPrefixed(depositsIterator.Value(), &deposit)
 	require.Equal(t, addrs[0], deposit.Depositor)
-	require.Equal(t, fourSteak.Add(fiveSteak), deposit.Amount)
+	require.Equal(t, fourStake.Add(fiveStake), deposit.Amount)
 	depositsIterator.Next()
 	keeper.cdc.MustUnmarshalBinaryLengthPrefixed(depositsIterator.Value(), &deposit)
 	require.Equal(t, addrs[1], deposit.Depositor)
-	require.Equal(t, fourSteak, deposit.Amount)
+	require.Equal(t, fourStake, deposit.Amount)
 	depositsIterator.Next()
 	require.False(t, depositsIterator.Valid())
 	depositsIterator.Close()
@@ -137,7 +171,7 @@ func TestDeposits(t *testing.T) {
 	// Test Refund Deposits
 	deposit, found = keeper.GetDeposit(ctx, proposalID, addrs[1])
 	require.True(t, found)
-	require.Equal(t, fourSteak, deposit.Amount)
+	require.Equal(t, fourStake, deposit.Amount)
 	keeper.RefundDeposits(ctx, proposalID)
 	deposit, found = keeper.GetDeposit(ctx, proposalID, addrs[1])
 	require.False(t, found)
@@ -149,13 +183,18 @@ func TestDeposits(t *testing.T) {
 func TestVotes(t *testing.T) {
 	mapp, keeper, _, addrs, _, _ := getMockApp(t, 2, GenesisState{}, nil)
 	SortAddresses(addrs)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
+	tp := testProposal()
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
 
-	proposal.SetStatus(StatusVotingPeriod)
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
 	// Test first vote
@@ -204,25 +243,33 @@ func TestVotes(t *testing.T) {
 
 func TestProposalQueues(t *testing.T) {
 	mapp, keeper, _, _, _, _ := getMockApp(t, 0, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	mapp.InitChainer(ctx, abci.RequestInitChain{})
 
 	// create test proposals
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
+	tp := testProposal()
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
 
-	inactiveIterator := keeper.InactiveProposalQueueIterator(ctx, proposal.GetDepositEndTime())
+	inactiveIterator := keeper.InactiveProposalQueueIterator(ctx, proposal.DepositEndTime)
 	require.True(t, inactiveIterator.Valid())
 	var proposalID uint64
 	keeper.cdc.UnmarshalBinaryLengthPrefixed(inactiveIterator.Value(), &proposalID)
-	require.Equal(t, proposalID, proposal.GetProposalID())
+	require.Equal(t, proposalID, proposal.ProposalID)
 	inactiveIterator.Close()
 
 	keeper.activateVotingPeriod(ctx, proposal)
 
-	activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.GetVotingEndTime())
+	proposal, ok := keeper.GetProposal(ctx, proposal.ProposalID)
+	require.True(t, ok)
+
+	activeIterator := keeper.ActiveProposalQueueIterator(ctx, proposal.VotingEndTime)
 	require.True(t, activeIterator.Valid())
 	keeper.cdc.UnmarshalBinaryLengthPrefixed(activeIterator.Value(), &proposalID)
-	require.Equal(t, proposalID, proposal.GetProposalID())
+	require.Equal(t, proposalID, proposal.ProposalID)
 	activeIterator.Close()
 }
diff --git a/x/gov/msgs_test.go b/x/gov/msgs_test.go
index 41e9cc65f..db5c4da0b 100644
--- a/x/gov/msgs_test.go
+++ b/x/gov/msgs_test.go
@@ -11,10 +11,10 @@ import (
 )
 
 var (
-	coinsPos         = sdk.Coins{sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000)}
-	coinsZero        = sdk.Coins{}
-	coinsPosNotAtoms = sdk.Coins{sdk.NewInt64Coin("foo", 10000)}
-	coinsMulti       = sdk.Coins{sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000), sdk.NewInt64Coin("foo", 10000)}
+	coinsPos         = sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000))
+	coinsZero        = sdk.NewCoins()
+	coinsPosNotAtoms = sdk.NewCoins(sdk.NewInt64Coin("foo", 10000))
+	coinsMulti       = sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000), sdk.NewInt64Coin("foo", 10000))
 )
 
 func init() {
@@ -23,7 +23,7 @@ func init() {
 
 // test ValidateBasic for MsgCreateValidator
 func TestMsgSubmitProposal(t *testing.T) {
-	_, addrs, _, _ := mock.CreateGenAccounts(1, sdk.Coins{})
+	_, addrs, _, _ := mock.CreateGenAccounts(1, sdk.NewCoins())
 	tests := []struct {
 		title, description string
 		proposalType       ProposalKind
@@ -65,7 +65,7 @@ func TestMsgDepositGetSignBytes(t *testing.T) {
 
 // test ValidateBasic for MsgDeposit
 func TestMsgDeposit(t *testing.T) {
-	_, addrs, _, _ := mock.CreateGenAccounts(1, sdk.Coins{})
+	_, addrs, _, _ := mock.CreateGenAccounts(1, sdk.NewCoins())
 	tests := []struct {
 		proposalID    uint64
 		depositorAddr sdk.AccAddress
@@ -90,7 +90,7 @@ func TestMsgDeposit(t *testing.T) {
 
 // test ValidateBasic for MsgDeposit
 func TestMsgVote(t *testing.T) {
-	_, addrs, _, _ := mock.CreateGenAccounts(1, sdk.Coins{})
+	_, addrs, _, _ := mock.CreateGenAccounts(1, sdk.NewCoins())
 	tests := []struct {
 		proposalID uint64
 		voterAddr  sdk.AccAddress
diff --git a/x/gov/proposals.go b/x/gov/proposals.go
index 94ffc151b..91790d531 100644
--- a/x/gov/proposals.go
+++ b/x/gov/proposals.go
@@ -9,81 +9,12 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-// Proposal interface
-type Proposal interface {
-	GetProposalID() uint64
-	SetProposalID(uint64)
+// Proposal is a struct used by gov module internally
+// embedds ProposalContent with additional fields to record the status of the proposal process
+type Proposal struct {
+	ProposalContent `json:"proposal_content"` // Proposal content interface
 
-	GetTitle() string
-	SetTitle(string)
-
-	GetDescription() string
-	SetDescription(string)
-
-	GetProposalType() ProposalKind
-	SetProposalType(ProposalKind)
-
-	GetStatus() ProposalStatus
-	SetStatus(ProposalStatus)
-
-	GetFinalTallyResult() TallyResult
-	SetFinalTallyResult(TallyResult)
-
-	GetSubmitTime() time.Time
-	SetSubmitTime(time.Time)
-
-	GetDepositEndTime() time.Time
-	SetDepositEndTime(time.Time)
-
-	GetTotalDeposit() sdk.Coins
-	SetTotalDeposit(sdk.Coins)
-
-	GetVotingStartTime() time.Time
-	SetVotingStartTime(time.Time)
-
-	GetVotingEndTime() time.Time
-	SetVotingEndTime(time.Time)
-
-	String() string
-}
-
-// Proposals is an array of proposal
-type Proposals []Proposal
-
-func (p Proposals) String() string {
-	out := "ID - (Status) [Type] Title\n"
-	for _, prop := range p {
-		out += fmt.Sprintf("%d - (%s) [%s] %s\n",
-			prop.GetProposalID(), prop.GetStatus(),
-			prop.GetProposalType(), prop.GetTitle())
-	}
-	return strings.TrimSpace(out)
-}
-
-// checks if two proposals are equal
-func ProposalEqual(proposalA Proposal, proposalB Proposal) bool {
-	if proposalA.GetProposalID() == proposalB.GetProposalID() &&
-		proposalA.GetTitle() == proposalB.GetTitle() &&
-		proposalA.GetDescription() == proposalB.GetDescription() &&
-		proposalA.GetProposalType() == proposalB.GetProposalType() &&
-		proposalA.GetStatus() == proposalB.GetStatus() &&
-		proposalA.GetFinalTallyResult().Equals(proposalB.GetFinalTallyResult()) &&
-		proposalA.GetSubmitTime().Equal(proposalB.GetSubmitTime()) &&
-		proposalA.GetDepositEndTime().Equal(proposalB.GetDepositEndTime()) &&
-		proposalA.GetTotalDeposit().IsEqual(proposalB.GetTotalDeposit()) &&
-		proposalA.GetVotingStartTime().Equal(proposalB.GetVotingStartTime()) &&
-		proposalA.GetVotingEndTime().Equal(proposalB.GetVotingEndTime()) {
-		return true
-	}
-	return false
-}
-
-// Text Proposals
-type TextProposal struct {
-	ProposalID   uint64       `json:"proposal_id"`   //  ID of the proposal
-	Title        string       `json:"title"`         //  Title of the proposal
-	Description  string       `json:"description"`   //  Description of the proposal
-	ProposalType ProposalKind `json:"proposal_type"` //  Type of proposal. Initial set {PlainTextProposal, SoftwareUpgradeProposal}
+	ProposalID uint64 `json:"proposal_id"` //  ID of the proposal
 
 	Status           ProposalStatus `json:"proposal_status"`    //  Status of the Proposal {Pending, Active, Passed, Rejected}
 	FinalTallyResult TallyResult    `json:"final_tally_result"` //  Result of Tallys
@@ -96,42 +27,8 @@ type TextProposal struct {
 	VotingEndTime   time.Time `json:"voting_end_time"`   // Time that the VotingPeriod for this proposal will end and votes will be tallied
 }
 
-// Implements Proposal Interface
-var _ Proposal = (*TextProposal)(nil)
-
 // nolint
-func (tp TextProposal) GetProposalID() uint64                      { return tp.ProposalID }
-func (tp *TextProposal) SetProposalID(proposalID uint64)           { tp.ProposalID = proposalID }
-func (tp TextProposal) GetTitle() string                           { return tp.Title }
-func (tp *TextProposal) SetTitle(title string)                     { tp.Title = title }
-func (tp TextProposal) GetDescription() string                     { return tp.Description }
-func (tp *TextProposal) SetDescription(description string)         { tp.Description = description }
-func (tp TextProposal) GetProposalType() ProposalKind              { return tp.ProposalType }
-func (tp *TextProposal) SetProposalType(proposalType ProposalKind) { tp.ProposalType = proposalType }
-func (tp TextProposal) GetStatus() ProposalStatus                  { return tp.Status }
-func (tp *TextProposal) SetStatus(status ProposalStatus)           { tp.Status = status }
-func (tp TextProposal) GetFinalTallyResult() TallyResult           { return tp.FinalTallyResult }
-func (tp *TextProposal) SetFinalTallyResult(tallyResult TallyResult) {
-	tp.FinalTallyResult = tallyResult
-}
-func (tp TextProposal) GetSubmitTime() time.Time            { return tp.SubmitTime }
-func (tp *TextProposal) SetSubmitTime(submitTime time.Time) { tp.SubmitTime = submitTime }
-func (tp TextProposal) GetDepositEndTime() time.Time        { return tp.DepositEndTime }
-func (tp *TextProposal) SetDepositEndTime(depositEndTime time.Time) {
-	tp.DepositEndTime = depositEndTime
-}
-func (tp TextProposal) GetTotalDeposit() sdk.Coins              { return tp.TotalDeposit }
-func (tp *TextProposal) SetTotalDeposit(totalDeposit sdk.Coins) { tp.TotalDeposit = totalDeposit }
-func (tp TextProposal) GetVotingStartTime() time.Time           { return tp.VotingStartTime }
-func (tp *TextProposal) SetVotingStartTime(votingStartTime time.Time) {
-	tp.VotingStartTime = votingStartTime
-}
-func (tp TextProposal) GetVotingEndTime() time.Time { return tp.VotingEndTime }
-func (tp *TextProposal) SetVotingEndTime(votingEndTime time.Time) {
-	tp.VotingEndTime = votingEndTime
-}
-
-func (tp TextProposal) String() string {
+func (p Proposal) String() string {
 	return fmt.Sprintf(`Proposal %d:
   Title:              %s
   Type:               %s
@@ -140,11 +37,76 @@ func (tp TextProposal) String() string {
   Deposit End Time:   %s
   Total Deposit:      %s
   Voting Start Time:  %s
-  Voting End Time:    %s`, tp.ProposalID, tp.Title, tp.ProposalType,
-		tp.Status, tp.SubmitTime, tp.DepositEndTime,
-		tp.TotalDeposit, tp.VotingStartTime, tp.VotingEndTime)
+  Voting End Time:    %s
+  Description:        %s`,
+		p.ProposalID, p.GetTitle(), p.ProposalType(),
+		p.Status, p.SubmitTime, p.DepositEndTime,
+		p.TotalDeposit, p.VotingStartTime, p.VotingEndTime, p.GetDescription(),
+	)
 }
 
+// ProposalContent is an interface that has title, description, and proposaltype
+// that the governance module can use to identify them and generate human readable messages
+// ProposalContent can have additional fields, which will handled by ProposalHandlers
+// via type assertion, e.g. parameter change amount in ParameterChangeProposal
+type ProposalContent interface {
+	GetTitle() string
+	GetDescription() string
+	ProposalType() ProposalKind
+}
+
+// Proposals is an array of proposal
+type Proposals []Proposal
+
+// nolint
+func (p Proposals) String() string {
+	out := "ID - (Status) [Type] Title\n"
+	for _, prop := range p {
+		out += fmt.Sprintf("%d - (%s) [%s] %s\n",
+			prop.ProposalID, prop.Status,
+			prop.ProposalType(), prop.GetTitle())
+	}
+	return strings.TrimSpace(out)
+}
+
+// Text Proposals
+type TextProposal struct {
+	Title       string `json:"title"`       //  Title of the proposal
+	Description string `json:"description"` //  Description of the proposal
+}
+
+func NewTextProposal(title, description string) TextProposal {
+	return TextProposal{
+		Title:       title,
+		Description: description,
+	}
+}
+
+// Implements Proposal Interface
+var _ ProposalContent = TextProposal{}
+
+// nolint
+func (tp TextProposal) GetTitle() string           { return tp.Title }
+func (tp TextProposal) GetDescription() string     { return tp.Description }
+func (tp TextProposal) ProposalType() ProposalKind { return ProposalTypeText }
+
+// Software Upgrade Proposals
+type SoftwareUpgradeProposal struct {
+	TextProposal
+}
+
+func NewSoftwareUpgradeProposal(title, description string) SoftwareUpgradeProposal {
+	return SoftwareUpgradeProposal{
+		TextProposal: NewTextProposal(title, description),
+	}
+}
+
+// Implements Proposal Interface
+var _ ProposalContent = SoftwareUpgradeProposal{}
+
+// nolint
+func (sup SoftwareUpgradeProposal) ProposalType() ProposalKind { return ProposalTypeSoftwareUpgrade }
+
 // ProposalQueue
 type ProposalQueue []uint64
 
diff --git a/x/gov/querier.go b/x/gov/querier.go
index b9f0fbf7f..881e2d53f 100644
--- a/x/gov/querier.go
+++ b/x/gov/querier.go
@@ -99,8 +99,8 @@ func queryProposal(ctx sdk.Context, path []string, req abci.RequestQuery, keeper
 		return nil, sdk.ErrUnknownRequest(sdk.AppendMsgToErr("incorrectly formatted request data", err.Error()))
 	}
 
-	proposal := keeper.GetProposal(ctx, params.ProposalID)
-	if proposal == nil {
+	proposal, ok := keeper.GetProposal(ctx, params.ProposalID)
+	if !ok {
 		return nil, ErrUnknownProposal(DefaultCodespace, params.ProposalID)
 	}
 
@@ -205,17 +205,17 @@ func queryTally(ctx sdk.Context, path []string, req abci.RequestQuery, keeper Ke
 
 	proposalID := params.ProposalID
 
-	proposal := keeper.GetProposal(ctx, proposalID)
-	if proposal == nil {
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	if !ok {
 		return nil, ErrUnknownProposal(DefaultCodespace, proposalID)
 	}
 
 	var tallyResult TallyResult
 
-	if proposal.GetStatus() == StatusDepositPeriod {
+	if proposal.Status == StatusDepositPeriod {
 		tallyResult = EmptyTallyResult()
-	} else if proposal.GetStatus() == StatusPassed || proposal.GetStatus() == StatusRejected {
-		tallyResult = proposal.GetFinalTallyResult()
+	} else if proposal.Status == StatusPassed || proposal.Status == StatusRejected {
+		tallyResult = proposal.FinalTallyResult
 	} else {
 		// proposal is in voting period
 		_, tallyResult = tally(ctx, keeper, proposal)
diff --git a/x/gov/querier_test.go b/x/gov/querier_test.go
index 25e8220b5..9c4edfcd5 100644
--- a/x/gov/querier_test.go
+++ b/x/gov/querier_test.go
@@ -227,12 +227,12 @@ func testQueries(t *testing.T) {
 	// Only proposal #1 should be in Deposit Period
 	proposals := getQueriedProposals(t, ctx, cdc, querier, nil, nil, StatusDepositPeriod, 0)
 	require.Len(t, proposals, 1)
-	require.Equal(t, proposalID1, proposals[0].GetProposalID())
+	require.Equal(t, proposalID1, proposals[0].ProposalID)
 	// Only proposals #2 and #3 should be in Voting Period
 	proposals = getQueriedProposals(t, ctx, cdc, querier, nil, nil, StatusVotingPeriod, 0)
 	require.Len(t, proposals, 2)
-	require.Equal(t, proposalID2, proposals[0].GetProposalID())
-	require.Equal(t, proposalID3, proposals[1].GetProposalID())
+	require.Equal(t, proposalID2, proposals[0].ProposalID)
+	require.Equal(t, proposalID3, proposals[1].ProposalID)
 
 	// Addrs[0] votes on proposals #2 & #3
 	handler(ctx, NewMsgVote(addrs[0], proposalID2, OptionYes))
@@ -243,8 +243,8 @@ func testQueries(t *testing.T) {
 
 	// Test query voted by addrs[0]
 	proposals = getQueriedProposals(t, ctx, cdc, querier, nil, addrs[0], StatusNil, 0)
-	require.Equal(t, proposalID2, (proposals[0]).GetProposalID())
-	require.Equal(t, proposalID3, (proposals[1]).GetProposalID())
+	require.Equal(t, proposalID2, (proposals[0]).ProposalID)
+	require.Equal(t, proposalID3, (proposals[1]).ProposalID)
 
 	// Test query votes on Proposal 2
 	votes := getQueriedVotes(t, ctx, cdc, querier, proposalID2)
@@ -263,26 +263,26 @@ func testQueries(t *testing.T) {
 
 	// Test query all proposals
 	proposals = getQueriedProposals(t, ctx, cdc, querier, nil, nil, StatusNil, 0)
-	require.Equal(t, proposalID1, (proposals[0]).GetProposalID())
-	require.Equal(t, proposalID2, (proposals[1]).GetProposalID())
-	require.Equal(t, proposalID3, (proposals[2]).GetProposalID())
+	require.Equal(t, proposalID1, (proposals[0]).ProposalID)
+	require.Equal(t, proposalID2, (proposals[1]).ProposalID)
+	require.Equal(t, proposalID3, (proposals[2]).ProposalID)
 
 	// Test query voted by addrs[1]
 	proposals = getQueriedProposals(t, ctx, cdc, querier, nil, addrs[1], StatusNil, 0)
-	require.Equal(t, proposalID3, (proposals[0]).GetProposalID())
+	require.Equal(t, proposalID3, (proposals[0]).ProposalID)
 
 	// Test query deposited by addrs[0]
 	proposals = getQueriedProposals(t, ctx, cdc, querier, addrs[0], nil, StatusNil, 0)
-	require.Equal(t, proposalID1, (proposals[0]).GetProposalID())
+	require.Equal(t, proposalID1, (proposals[0]).ProposalID)
 
 	// Test query deposited by addr2
 	proposals = getQueriedProposals(t, ctx, cdc, querier, addrs[1], nil, StatusNil, 0)
-	require.Equal(t, proposalID2, (proposals[0]).GetProposalID())
-	require.Equal(t, proposalID3, (proposals[1]).GetProposalID())
+	require.Equal(t, proposalID2, (proposals[0]).ProposalID)
+	require.Equal(t, proposalID3, (proposals[1]).ProposalID)
 
 	// Test query voted AND deposited by addr1
 	proposals = getQueriedProposals(t, ctx, cdc, querier, addrs[0], addrs[0], StatusNil, 0)
-	require.Equal(t, proposalID2, (proposals[0]).GetProposalID())
+	require.Equal(t, proposalID2, (proposals[0]).ProposalID)
 
 	// Test Tally Query
 	tally := getQueriedTally(t, ctx, cdc, querier, proposalID2)
diff --git a/x/gov/simulation/invariants.go b/x/gov/simulation/invariants.go
deleted file mode 100644
index 89f886ed7..000000000
--- a/x/gov/simulation/invariants.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package simulation
-
-import (
-	sdk "github.com/cosmos/cosmos-sdk/types"
-)
-
-// AllInvariants tests all governance invariants
-func AllInvariants() sdk.Invariant {
-	return func(ctx sdk.Context) error {
-		// TODO Add some invariants!
-		// Checking proposal queues, no passed-but-unexecuted proposals, etc.
-		return nil
-	}
-}
diff --git a/x/gov/simulation/msgs.go b/x/gov/simulation/msgs.go
index 4c5eddd37..5541fb2bd 100644
--- a/x/gov/simulation/msgs.go
+++ b/x/gov/simulation/msgs.go
@@ -9,7 +9,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/gov"
-	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
 )
 
 // SimulateSubmittingVotingAndSlashingForProposal simulates creating a msg Submit Proposal
@@ -38,17 +38,20 @@ func SimulateSubmittingVotingAndSlashingForProposal(k gov.Keeper) simulation.Ope
 	})
 	statePercentageArray := []float64{1, .9, .75, .4, .15, 0}
 	curNumVotesState := 1
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account) (
+		opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
+
 		// 1) submit proposal now
 		sender := simulation.RandomAcc(r, accs)
 		msg, err := simulationCreateMsgSubmitProposal(r, sender)
 		if err != nil {
-			return "", nil, err
+			return simulation.NoOpMsg(), nil, err
 		}
-		action, ok := simulateHandleMsgSubmitProposal(msg, handler, ctx, event)
+		ok := simulateHandleMsgSubmitProposal(msg, handler, ctx)
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
 		// don't schedule votes if proposal failed
 		if !ok {
-			return action, nil, nil
+			return opMsg, nil, nil
 		}
 		proposalID := k.GetLastProposalID(ctx)
 		// 2) Schedule operations for votes
@@ -69,7 +72,7 @@ func SimulateSubmittingVotingAndSlashingForProposal(k gov.Keeper) simulation.Ope
 		// TODO: Find a way to check if a validator was slashed other than just checking their balance a block
 		// before and after.
 
-		return action, fops, nil
+		return opMsg, fops, nil
 	}
 }
 
@@ -77,27 +80,27 @@ func SimulateSubmittingVotingAndSlashingForProposal(k gov.Keeper) simulation.Ope
 // Note: Currently doesn't ensure that the proposal txt is in JSON form
 func SimulateMsgSubmitProposal(k gov.Keeper) simulation.Operation {
 	handler := gov.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOps []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account) (
+		opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
+
 		sender := simulation.RandomAcc(r, accs)
 		msg, err := simulationCreateMsgSubmitProposal(r, sender)
 		if err != nil {
-			return "", nil, err
+			return simulation.NoOpMsg(), nil, err
 		}
-		action, _ = simulateHandleMsgSubmitProposal(msg, handler, ctx, event)
-		return action, nil, nil
+		ok := simulateHandleMsgSubmitProposal(msg, handler, ctx)
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
-func simulateHandleMsgSubmitProposal(msg gov.MsgSubmitProposal, handler sdk.Handler, ctx sdk.Context, event func(string)) (action string, ok bool) {
+func simulateHandleMsgSubmitProposal(msg gov.MsgSubmitProposal, handler sdk.Handler, ctx sdk.Context) (ok bool) {
 	ctx, write := ctx.CacheContext()
-	result := handler(ctx, msg)
-	ok = result.IsOK()
+	ok = handler(ctx, msg).IsOK()
 	if ok {
 		write()
 	}
-	event(fmt.Sprintf("gov/MsgSubmitProposal/%v", ok))
-	action = fmt.Sprintf("TestMsgSubmitProposal: ok %v, msg %s", ok, msg.GetSignBytes())
-	return
+	return ok
 }
 
 func simulationCreateMsgSubmitProposal(r *rand.Rand, sender simulation.Account) (msg gov.MsgSubmitProposal, err error) {
@@ -117,25 +120,27 @@ func simulationCreateMsgSubmitProposal(r *rand.Rand, sender simulation.Account)
 
 // SimulateMsgDeposit
 func SimulateMsgDeposit(k gov.Keeper) simulation.Operation {
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account) (
+		opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
+
 		acc := simulation.RandomAcc(r, accs)
 		proposalID, ok := randomProposalID(r, k, ctx)
 		if !ok {
-			return "no-operation", nil, nil
+			return simulation.NoOpMsg(), nil, nil
 		}
 		deposit := randomDeposit(r)
 		msg := gov.NewMsgDeposit(acc.Address, proposalID, deposit)
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 		ctx, write := ctx.CacheContext()
-		result := gov.NewHandler(k)(ctx, msg)
-		if result.IsOK() {
+		ok = gov.NewHandler(k)(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
-		event(fmt.Sprintf("gov/MsgDeposit/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgDeposit: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
@@ -147,35 +152,35 @@ func SimulateMsgVote(k gov.Keeper) simulation.Operation {
 
 // nolint: unparam
 func operationSimulateMsgVote(k gov.Keeper, acc simulation.Account, proposalID uint64) simulation.Operation {
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account) (
+		opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
+
 		if acc.Equals(simulation.Account{}) {
 			acc = simulation.RandomAcc(r, accs)
 		}
 
-		var ok bool
-
 		if proposalID < 0 {
+			var ok bool
 			proposalID, ok = randomProposalID(r, k, ctx)
 			if !ok {
-				return "no-operation", nil, nil
+				return simulation.NoOpMsg(), nil, nil
 			}
 		}
 		option := randomVotingOption(r)
 
 		msg := gov.NewMsgVote(acc.Address, proposalID, option)
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 
 		ctx, write := ctx.CacheContext()
-		result := gov.NewHandler(k)(ctx, msg)
-		if result.IsOK() {
+		ok := gov.NewHandler(k)(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
 
-		event(fmt.Sprintf("gov/MsgVote/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgVote: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
diff --git a/x/gov/tally.go b/x/gov/tally.go
index bdc5003fa..d8ce2e8d2 100644
--- a/x/gov/tally.go
+++ b/x/gov/tally.go
@@ -49,7 +49,7 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 	})
 
 	// iterate over all the votes
-	votesIterator := keeper.GetVotes(ctx, proposal.GetProposalID())
+	votesIterator := keeper.GetVotes(ctx, proposal.ProposalID)
 	defer votesIterator.Close()
 	for ; votesIterator.Valid(); votesIterator.Next() {
 		vote := &Vote{}
diff --git a/x/gov/tally_test.go b/x/gov/tally_test.go
index cf89293ee..a84abd711 100644
--- a/x/gov/tally_test.go
+++ b/x/gov/tally_test.go
@@ -38,7 +38,10 @@ func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context,
 
 func TestTallyNoOneVotes(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -50,12 +53,16 @@ func TestTallyNoOneVotes(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 5})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.False(t, passes)
 	require.True(t, tallyResults.Equals(EmptyTallyResult()))
@@ -63,7 +70,10 @@ func TestTallyNoOneVotes(t *testing.T) {
 
 func TestTallyNoQuorum(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -75,21 +85,28 @@ func TestTallyNoQuorum(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{2, 5})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 
-	passes, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, _ := tally(ctx, keeper, proposal)
 	require.False(t, passes)
 }
 
 func TestTallyOnlyValidatorsAllYes(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -101,17 +118,21 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 5})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -119,7 +140,10 @@ func TestTallyOnlyValidatorsAllYes(t *testing.T) {
 
 func TestTallyOnlyValidators51No(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -131,24 +155,31 @@ func TestTallyOnlyValidators51No(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 6})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionNo)
 	require.Nil(t, err)
 
-	passes, _ := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, _ := tally(ctx, keeper, proposal)
 
 	require.False(t, passes)
 }
 
 func TestTallyOnlyValidators51Yes(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -160,19 +191,23 @@ func TestTallyOnlyValidators51Yes(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{6, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -180,7 +215,10 @@ func TestTallyOnlyValidators51Yes(t *testing.T) {
 
 func TestTallyOnlyValidatorsVetoed(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -192,19 +230,23 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{6, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNoWithVeto)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -212,7 +254,10 @@ func TestTallyOnlyValidatorsVetoed(t *testing.T) {
 
 func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -224,19 +269,23 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{6, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionAbstain)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionAbstain)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionNo)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionYes)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -244,7 +293,10 @@ func TestTallyOnlyValidatorsAbstainPasses(t *testing.T) {
 
 func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -256,19 +308,23 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{6, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionAbstain)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionAbstain)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -276,7 +332,10 @@ func TestTallyOnlyValidatorsAbstainFails(t *testing.T) {
 
 func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -288,17 +347,21 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{6, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -306,7 +369,10 @@ func TestTallyOnlyValidatorsNonVoter(t *testing.T) {
 
 func TestTallyDelgatorOverride(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -322,12 +388,14 @@ func TestTallyDelgatorOverride(t *testing.T) {
 	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(sdk.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
 	require.Nil(t, err)
@@ -336,7 +404,9 @@ func TestTallyDelgatorOverride(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[3], OptionNo)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -344,7 +414,10 @@ func TestTallyDelgatorOverride(t *testing.T) {
 
 func TestTallyDelgatorInherit(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -360,19 +433,23 @@ func TestTallyDelgatorInherit(t *testing.T) {
 	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(sdk.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionNo)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionNo)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionNo)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionYes)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -380,7 +457,10 @@ func TestTallyDelgatorInherit(t *testing.T) {
 
 func TestTallyDelgatorMultipleOverride(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -398,12 +478,14 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 	delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewCoin(sdk.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg2)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionYes)
 	require.Nil(t, err)
@@ -412,7 +494,9 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 	err = keeper.AddVote(ctx, proposalID, addrs[3], OptionNo)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -420,7 +504,10 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 
 func TestTallyDelgatorMultipleInherit(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -451,19 +538,23 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
 
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionNo)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.False(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
@@ -471,7 +562,10 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
 
 func TestTallyJailedValidator(t *testing.T) {
 	mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10, GenesisState{}, nil)
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
@@ -496,19 +590,23 @@ func TestTallyJailedValidator(t *testing.T) {
 
 	staking.EndBlocker(ctx, sk)
 
-	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
-	proposalID := proposal.GetProposalID()
-	proposal.SetStatus(StatusVotingPeriod)
+	tp := TextProposal{"Test", "description"}
+	proposal, err := keeper.SubmitProposal(ctx, tp)
+	require.NoError(t, err)
+	proposalID := proposal.ProposalID
+	proposal.Status = StatusVotingPeriod
 	keeper.SetProposal(ctx, proposal)
 
-	err := keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
+	err = keeper.AddVote(ctx, proposalID, addrs[0], OptionYes)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[1], OptionNo)
 	require.Nil(t, err)
 	err = keeper.AddVote(ctx, proposalID, addrs[2], OptionNo)
 	require.Nil(t, err)
 
-	passes, tallyResults := tally(ctx, keeper, keeper.GetProposal(ctx, proposalID))
+	proposal, ok := keeper.GetProposal(ctx, proposalID)
+	require.True(t, ok)
+	passes, tallyResults := tally(ctx, keeper, proposal)
 
 	require.True(t, passes)
 	require.False(t, tallyResults.Equals(EmptyTallyResult()))
diff --git a/x/gov/test_common.go b/x/gov/test_common.go
index 0c0d74306..a14251841 100644
--- a/x/gov/test_common.go
+++ b/x/gov/test_common.go
@@ -146,3 +146,12 @@ func SortByteArrays(src [][]byte) [][]byte {
 	sort.Sort(sorted)
 	return sorted
 }
+
+func testProposal() TextProposal {
+	return NewTextProposal("Test", "description")
+}
+
+// checks if two proposals are equal (note: slow, for tests only)
+func ProposalEqual(proposalA Proposal, proposalB Proposal) bool {
+	return bytes.Equal(msgCdc.MustMarshalBinaryBare(proposalA), msgCdc.MustMarshalBinaryBare(proposalB))
+}
diff --git a/x/ibc/app_test.go b/x/ibc/app_test.go
index 0b1e7d9da..ca51ae9d8 100644
--- a/x/ibc/app_test.go
+++ b/x/ibc/app_test.go
@@ -72,10 +72,17 @@ func TestIBCMsgs(t *testing.T) {
 		Sequence:  0,
 	}
 
-	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, []sdk.Msg{transferMsg}, []uint64{0}, []uint64{0}, true, true, priv1)
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{transferMsg}, []uint64{0}, []uint64{0}, true, true, priv1)
 	mock.CheckBalance(t, mapp, addr1, emptyCoins)
-	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, []sdk.Msg{transferMsg}, []uint64{0}, []uint64{1}, false, false, priv1)
-	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, []sdk.Msg{receiveMsg}, []uint64{0}, []uint64{2}, true, true, priv1)
+
+	header = abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{transferMsg}, []uint64{0}, []uint64{1}, false, false, priv1)
+
+	header = abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{receiveMsg}, []uint64{0}, []uint64{2}, true, true, priv1)
 	mock.CheckBalance(t, mapp, addr1, coins)
-	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, []sdk.Msg{receiveMsg}, []uint64{0}, []uint64{2}, false, false, priv1)
+
+	header = abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{receiveMsg}, []uint64{0}, []uint64{2}, false, false, priv1)
 }
diff --git a/x/mint/client/cli/query.go b/x/mint/client/cli/query.go
new file mode 100644
index 000000000..498024073
--- /dev/null
+++ b/x/mint/client/cli/query.go
@@ -0,0 +1,89 @@
+package cli
+
+import (
+	"fmt"
+
+	"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/mint"
+	"github.com/spf13/cobra"
+)
+
+// GetCmdQueryParams implements a command to return the current minting
+// parameters.
+func GetCmdQueryParams(cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "params",
+		Short: "Query the current minting parameters",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+
+			route := fmt.Sprintf("custom/%s/%s", mint.QuerierRoute, mint.QueryParameters)
+			res, err := cliCtx.QueryWithData(route, nil)
+			if err != nil {
+				return err
+			}
+
+			var params mint.Params
+			if err := cdc.UnmarshalJSON(res, &params); err != nil {
+				return err
+			}
+
+			return cliCtx.PrintOutput(params)
+		},
+	}
+}
+
+// GetCmdQueryInflation implements a command to return the current minting
+// inflation value.
+func GetCmdQueryInflation(cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "inflation",
+		Short: "Query the current minting inflation value",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+
+			route := fmt.Sprintf("custom/%s/%s", mint.QuerierRoute, mint.QueryInflation)
+			res, err := cliCtx.QueryWithData(route, nil)
+			if err != nil {
+				return err
+			}
+
+			var inflation sdk.Dec
+			if err := cdc.UnmarshalJSON(res, &inflation); err != nil {
+				return err
+			}
+
+			return cliCtx.PrintOutput(inflation)
+		},
+	}
+}
+
+// GetCmdQueryAnnualProvisions implements a command to return the current minting
+// annual provisions value.
+func GetCmdQueryAnnualProvisions(cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   "annual-provisions",
+		Short: "Query the current minting annual provisions value",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+
+			route := fmt.Sprintf("custom/%s/%s", mint.QuerierRoute, mint.QueryAnnualProvisions)
+			res, err := cliCtx.QueryWithData(route, nil)
+			if err != nil {
+				return err
+			}
+
+			var inflation sdk.Dec
+			if err := cdc.UnmarshalJSON(res, &inflation); err != nil {
+				return err
+			}
+
+			return cliCtx.PrintOutput(inflation)
+		},
+	}
+}
diff --git a/x/mint/client/module_client.go b/x/mint/client/module_client.go
new file mode 100644
index 000000000..96f6c00fd
--- /dev/null
+++ b/x/mint/client/module_client.go
@@ -0,0 +1,47 @@
+package clientpackage
+
+import (
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/x/mint"
+	"github.com/cosmos/cosmos-sdk/x/mint/client/cli"
+	"github.com/spf13/cobra"
+	"github.com/tendermint/go-amino"
+)
+
+// ModuleClient exports all CLI client functionality from the minting module.
+type ModuleClient struct {
+	storeKey string
+	cdc      *amino.Codec
+}
+
+func NewModuleClient(storeKey string, cdc *amino.Codec) ModuleClient {
+	return ModuleClient{storeKey, cdc}
+}
+
+// GetQueryCmd returns the cli query commands for the minting module.
+func (mc ModuleClient) GetQueryCmd() *cobra.Command {
+	mintingQueryCmd := &cobra.Command{
+		Use:   mint.ModuleName,
+		Short: "Querying commands for the minting module",
+	}
+
+	mintingQueryCmd.AddCommand(
+		client.GetCommands(
+			cli.GetCmdQueryParams(mc.cdc),
+			cli.GetCmdQueryInflation(mc.cdc),
+			cli.GetCmdQueryAnnualProvisions(mc.cdc),
+		)...,
+	)
+
+	return mintingQueryCmd
+}
+
+// GetTxCmd returns the transaction commands for the minting module.
+func (mc ModuleClient) GetTxCmd() *cobra.Command {
+	mintTxCmd := &cobra.Command{
+		Use:   mint.ModuleName,
+		Short: "Minting transaction subcommands",
+	}
+
+	return mintTxCmd
+}
diff --git a/x/mint/client/rest/query.go b/x/mint/client/rest/query.go
new file mode 100644
index 000000000..9bc436a6d
--- /dev/null
+++ b/x/mint/client/rest/query.go
@@ -0,0 +1,71 @@
+package rest
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/types/rest"
+	"github.com/cosmos/cosmos-sdk/x/mint"
+	"github.com/gorilla/mux"
+)
+
+func registerQueryRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec) {
+	r.HandleFunc(
+		"/minting/parameters",
+		queryParamsHandlerFn(cdc, cliCtx),
+	).Methods("GET")
+
+	r.HandleFunc(
+		"/minting/inflation",
+		queryInflationHandlerFn(cdc, cliCtx),
+	).Methods("GET")
+
+	r.HandleFunc(
+		"/minting/annual-provisions",
+		queryAnnualProvisionsHandlerFn(cdc, cliCtx),
+	).Methods("GET")
+}
+
+func queryParamsHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		route := fmt.Sprintf("custom/%s/%s", mint.QuerierRoute, mint.QueryParameters)
+
+		res, err := cliCtx.QueryWithData(route, nil)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
+	}
+}
+
+func queryInflationHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		route := fmt.Sprintf("custom/%s/%s", mint.QuerierRoute, mint.QueryInflation)
+
+		res, err := cliCtx.QueryWithData(route, nil)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
+	}
+}
+
+func queryAnnualProvisionsHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		route := fmt.Sprintf("custom/%s/%s", mint.QuerierRoute, mint.QueryAnnualProvisions)
+
+		res, err := cliCtx.QueryWithData(route, nil)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
+	}
+}
diff --git a/x/mint/client/rest/rest.go b/x/mint/client/rest/rest.go
new file mode 100644
index 000000000..cedfa72c7
--- /dev/null
+++ b/x/mint/client/rest/rest.go
@@ -0,0 +1,12 @@
+package rest
+
+import (
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/gorilla/mux"
+)
+
+// RegisterRoutes registers minting module REST handlers on the provided router.
+func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec) {
+	registerQueryRoutes(cliCtx, r, cdc)
+}
diff --git a/x/mint/genesis.go b/x/mint/genesis.go
index 27615ed7e..11f96c6f9 100644
--- a/x/mint/genesis.go
+++ b/x/mint/genesis.go
@@ -4,12 +4,13 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-// GenesisState - all distribution state that must be provided at genesis
+// GenesisState - minter state
 type GenesisState struct {
 	Minter Minter `json:"minter"` // minter object
 	Params Params `json:"params"` // inflation params
 }
 
+// NewGenesisState creates a new GenesisState object
 func NewGenesisState(minter Minter, params Params) GenesisState {
 	return GenesisState{
 		Minter: minter,
@@ -17,7 +18,7 @@ func NewGenesisState(minter Minter, params Params) GenesisState {
 	}
 }
 
-// get raw genesis raw message for testing
+// DefaultGenesisState creates a default GenesisState object
 func DefaultGenesisState() GenesisState {
 	return GenesisState{
 		Minter: DefaultInitialMinter(),
@@ -31,8 +32,7 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, data GenesisState) {
 	keeper.SetParams(ctx, data.Params)
 }
 
-// ExportGenesis returns a GenesisState for a given context and keeper. The
-// GenesisState will contain the pool, and validator/delegator distribution info's
+// ExportGenesis returns a GenesisState for a given context and keeper.
 func ExportGenesis(ctx sdk.Context, keeper Keeper) GenesisState {
 
 	minter := keeper.GetMinter(ctx)
@@ -40,8 +40,8 @@ func ExportGenesis(ctx sdk.Context, keeper Keeper) GenesisState {
 	return NewGenesisState(minter, params)
 }
 
-// ValidateGenesis validates the provided staking genesis state to ensure the
-// expected invariants holds. (i.e. params in correct bounds, no duplicate validators)
+// ValidateGenesis validates the provided genesis state to ensure the
+// expected invariants holds.
 func ValidateGenesis(data GenesisState) error {
 	err := validateParams(data.Params)
 	if err != nil {
diff --git a/x/mint/keeper.go b/x/mint/keeper.go
index e532fa744..42a9f19fb 100644
--- a/x/mint/keeper.go
+++ b/x/mint/keeper.go
@@ -6,6 +6,20 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/params"
 )
 
+const (
+	// ModuleName is the name of the module
+	ModuleName = "minting"
+
+	// default paramspace for params keeper
+	DefaultParamspace = "mint"
+
+	// StoreKey is the default store key for mint
+	StoreKey = "mint"
+
+	// QuerierRoute is the querier route for the minting store.
+	QuerierRoute = StoreKey
+)
+
 // keeper of the staking store
 type Keeper struct {
 	storeKey   sdk.StoreKey
@@ -45,14 +59,6 @@ func ParamKeyTable() params.KeyTable {
 	)
 }
 
-const (
-	// default paramspace for params keeper
-	DefaultParamspace = "mint"
-
-	// StoreKey is the default store key for mint
-	StoreKey = "mint"
-)
-
 //______________________________________________________________________
 
 // get the minter
diff --git a/x/mint/minter.go b/x/mint/minter.go
index 761d9d1e6..eff30785f 100644
--- a/x/mint/minter.go
+++ b/x/mint/minter.go
@@ -6,22 +6,22 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-// Minter represents the minting state
+// Minter represents the minting state.
 type Minter struct {
 	Inflation        sdk.Dec `json:"inflation"`         // current annual inflation rate
 	AnnualProvisions sdk.Dec `json:"annual_provisions"` // current annual expected provisions
 }
 
-// Create a new minter object
+// NewMinter returns a new Minter object with the given inflation and annual
+// provisions values.
 func NewMinter(inflation, annualProvisions sdk.Dec) Minter {
-
 	return Minter{
 		Inflation:        inflation,
 		AnnualProvisions: annualProvisions,
 	}
 }
 
-// minter object for a new chain
+// InitialMinter returns an initial Minter object with a given inflation value.
 func InitialMinter(inflation sdk.Dec) Minter {
 	return NewMinter(
 		inflation,
@@ -29,8 +29,8 @@ func InitialMinter(inflation sdk.Dec) Minter {
 	)
 }
 
-// default initial minter object for a new chain
-// which uses an inflation rate of 13%
+// DefaultInitialMinter returns a default initial Minter object for a new chain
+// which uses an inflation rate of 13%.
 func DefaultInitialMinter() Minter {
 	return InitialMinter(
 		sdk.NewDecWithPrec(13, 2),
@@ -45,10 +45,8 @@ func validateMinter(minter Minter) error {
 	return nil
 }
 
-// get the new inflation rate for the next hour
-func (m Minter) NextInflationRate(params Params, bondedRatio sdk.Dec) (
-	inflation sdk.Dec) {
-
+// NextInflationRate returns the new inflation rate for the next hour.
+func (m Minter) NextInflationRate(params Params, bondedRatio sdk.Dec) sdk.Dec {
 	// The target annual inflation rate is recalculated for each previsions cycle. The
 	// inflation is also subject to a rate change (positive or negative) depending on
 	// the distance from the desired ratio (67%). The maximum rate change possible is
@@ -61,8 +59,8 @@ func (m Minter) NextInflationRate(params Params, bondedRatio sdk.Dec) (
 		Mul(params.InflationRateChange)
 	inflationRateChange := inflationRateChangePerYear.Quo(sdk.NewDec(int64(params.BlocksPerYear)))
 
-	// increase the new annual inflation for this next cycle
-	inflation = m.Inflation.Add(inflationRateChange)
+	// adjust the new annual inflation for this next cycle
+	inflation := m.Inflation.Add(inflationRateChange) // note inflationRateChange may be negative
 	if inflation.GT(params.InflationMax) {
 		inflation = params.InflationMax
 	}
@@ -73,14 +71,14 @@ func (m Minter) NextInflationRate(params Params, bondedRatio sdk.Dec) (
 	return inflation
 }
 
-// calculate the annual provisions based on current total supply and inflation rate
-func (m Minter) NextAnnualProvisions(params Params, totalSupply sdk.Int) (
-	provisions sdk.Dec) {
-
+// NextAnnualProvisions returns the annual provisions based on current total
+// supply and inflation rate.
+func (m Minter) NextAnnualProvisions(_ Params, totalSupply sdk.Int) sdk.Dec {
 	return m.Inflation.MulInt(totalSupply)
 }
 
-// get the provisions for a block based on the annual provisions rate
+// BlockProvision returns the provisions for a block based on the annual
+// provisions rate.
 func (m Minter) BlockProvision(params Params) sdk.Coin {
 	provisionAmt := m.AnnualProvisions.QuoInt(sdk.NewInt(int64(params.BlocksPerYear)))
 	return sdk.NewCoin(params.MintDenom, provisionAmt.TruncateInt())
diff --git a/x/mint/params.go b/x/mint/params.go
index 38366851e..f1bd7e37d 100644
--- a/x/mint/params.go
+++ b/x/mint/params.go
@@ -56,3 +56,17 @@ func validateParams(params Params) error {
 	}
 	return nil
 }
+
+func (p Params) String() string {
+	return fmt.Sprintf(`Minting Params:
+  Mint Denom:             %s
+  Inflation Rate Change:  %s
+  Inflation Max:          %s
+  Inflation Min:          %s
+  Goal Bonded:            %s
+  Blocks Per Year:        %d
+`,
+		p.MintDenom, p.InflationRateChange, p.InflationMax,
+		p.InflationMin, p.GoalBonded, p.BlocksPerYear,
+	)
+}
diff --git a/x/mint/querier.go b/x/mint/querier.go
new file mode 100644
index 000000000..21d35ce15
--- /dev/null
+++ b/x/mint/querier.go
@@ -0,0 +1,68 @@
+package mint
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	abci "github.com/tendermint/tendermint/abci/types"
+)
+
+// Query endpoints supported by the minting querier
+const (
+	QueryParameters       = "parameters"
+	QueryInflation        = "inflation"
+	QueryAnnualProvisions = "annual_provisions"
+)
+
+// NewQuerier returns a minting Querier handler.
+func NewQuerier(k Keeper) sdk.Querier {
+	return func(ctx sdk.Context, path []string, _ abci.RequestQuery) ([]byte, sdk.Error) {
+		switch path[0] {
+		case QueryParameters:
+			return queryParams(ctx, k)
+
+		case QueryInflation:
+			return queryInflation(ctx, k)
+
+		case QueryAnnualProvisions:
+			return queryAnnualProvisions(ctx, k)
+
+		default:
+			return nil, sdk.ErrUnknownRequest(fmt.Sprintf("unknown minting query endpoint: %s", path[0]))
+		}
+	}
+}
+
+func queryParams(ctx sdk.Context, k Keeper) ([]byte, sdk.Error) {
+	params := k.GetParams(ctx)
+
+	res, err := codec.MarshalJSONIndent(k.cdc, params)
+	if err != nil {
+		return nil, sdk.ErrInternal(sdk.AppendMsgToErr("failed to marshal JSON", err.Error()))
+	}
+
+	return res, nil
+}
+
+func queryInflation(ctx sdk.Context, k Keeper) ([]byte, sdk.Error) {
+	minter := k.GetMinter(ctx)
+
+	res, err := codec.MarshalJSONIndent(k.cdc, minter.Inflation)
+	if err != nil {
+		return nil, sdk.ErrInternal(sdk.AppendMsgToErr("failed to marshal JSON", err.Error()))
+	}
+
+	return res, nil
+}
+
+func queryAnnualProvisions(ctx sdk.Context, k Keeper) ([]byte, sdk.Error) {
+	minter := k.GetMinter(ctx)
+
+	res, err := codec.MarshalJSONIndent(k.cdc, minter.AnnualProvisions)
+	if err != nil {
+		return nil, sdk.ErrInternal(sdk.AppendMsgToErr("failed to marshal JSON", err.Error()))
+	}
+
+	return res, nil
+}
diff --git a/x/mint/querier_test.go b/x/mint/querier_test.go
new file mode 100644
index 000000000..e9f3c8d6c
--- /dev/null
+++ b/x/mint/querier_test.go
@@ -0,0 +1,74 @@
+package mint
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+)
+
+func TestNewQuerier(t *testing.T) {
+	input := newTestInput(t)
+	querier := NewQuerier(input.mintKeeper)
+
+	query := abci.RequestQuery{
+		Path: "",
+		Data: []byte{},
+	}
+
+	_, err := querier(input.ctx, []string{QueryParameters}, query)
+	require.NoError(t, err)
+
+	_, err = querier(input.ctx, []string{QueryInflation}, query)
+	require.NoError(t, err)
+
+	_, err = querier(input.ctx, []string{QueryAnnualProvisions}, query)
+	require.NoError(t, err)
+
+	_, err = querier(input.ctx, []string{"foo"}, query)
+	require.Error(t, err)
+}
+
+func TestQueryParams(t *testing.T) {
+	input := newTestInput(t)
+
+	var params Params
+
+	res, sdkErr := queryParams(input.ctx, input.mintKeeper)
+	require.NoError(t, sdkErr)
+
+	err := input.cdc.UnmarshalJSON(res, &params)
+	require.NoError(t, err)
+
+	require.Equal(t, input.mintKeeper.GetParams(input.ctx), params)
+}
+
+func TestQueryInflation(t *testing.T) {
+	input := newTestInput(t)
+
+	var inflation sdk.Dec
+
+	res, sdkErr := queryInflation(input.ctx, input.mintKeeper)
+	require.NoError(t, sdkErr)
+
+	err := input.cdc.UnmarshalJSON(res, &inflation)
+	require.NoError(t, err)
+
+	require.Equal(t, input.mintKeeper.GetMinter(input.ctx).Inflation, inflation)
+}
+
+func TestQueryAnnualProvisions(t *testing.T) {
+	input := newTestInput(t)
+
+	var annualProvisions sdk.Dec
+
+	res, sdkErr := queryAnnualProvisions(input.ctx, input.mintKeeper)
+	require.NoError(t, sdkErr)
+
+	err := input.cdc.UnmarshalJSON(res, &annualProvisions)
+	require.NoError(t, err)
+
+	require.Equal(t, input.mintKeeper.GetMinter(input.ctx).AnnualProvisions, annualProvisions)
+}
diff --git a/x/mint/test_common.go b/x/mint/test_common.go
new file mode 100644
index 000000000..f699acda2
--- /dev/null
+++ b/x/mint/test_common.go
@@ -0,0 +1,75 @@
+package mint
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/libs/log"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/store"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+	"github.com/cosmos/cosmos-sdk/x/bank"
+	"github.com/cosmos/cosmos-sdk/x/params"
+	"github.com/cosmos/cosmos-sdk/x/staking"
+	dbm "github.com/tendermint/tendermint/libs/db"
+)
+
+type testInput struct {
+	ctx        sdk.Context
+	cdc        *codec.Codec
+	mintKeeper Keeper
+}
+
+func createTestCodec() *codec.Codec {
+	cdc := codec.New()
+	codec.RegisterCrypto(cdc)
+	return cdc
+}
+
+func newTestInput(t *testing.T) testInput {
+	cdc := createTestCodec()
+	db := dbm.NewMemDB()
+
+	keyAcc := sdk.NewKVStoreKey(auth.StoreKey)
+	keyStaking := sdk.NewKVStoreKey(staking.StoreKey)
+	tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey)
+	keyParams := sdk.NewKVStoreKey(params.StoreKey)
+	tkeyParams := sdk.NewTransientStoreKey(params.TStoreKey)
+	keyFeeCollection := sdk.NewKVStoreKey(auth.FeeStoreKey)
+	keyMint := sdk.NewKVStoreKey(StoreKey)
+
+	ms := store.NewCommitMultiStore(db)
+	ms.MountStoreWithDB(keyAcc, sdk.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(tkeyStaking, sdk.StoreTypeTransient, nil)
+	ms.MountStoreWithDB(keyStaking, sdk.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(keyFeeCollection, sdk.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(keyParams, sdk.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(keyMint, sdk.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(tkeyParams, sdk.StoreTypeTransient, db)
+	err := ms.LoadLatestVersion()
+	require.Nil(t, err)
+
+	paramsKeeper := params.NewKeeper(cdc, keyParams, tkeyParams)
+	feeCollectionKeeper := auth.NewFeeCollectionKeeper(cdc, keyFeeCollection)
+	accountKeeper := auth.NewAccountKeeper(cdc, keyAcc, paramsKeeper.Subspace(auth.DefaultParamspace), auth.ProtoBaseAccount)
+	bankKeeper := bank.NewBaseKeeper(accountKeeper, paramsKeeper.Subspace(bank.DefaultParamspace), bank.DefaultCodespace)
+	stakingKeeper := staking.NewKeeper(
+		cdc, keyStaking, tkeyStaking, bankKeeper, paramsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace,
+	)
+	mintKeeper := NewKeeper(
+		cdc, keyMint, paramsKeeper.Subspace(DefaultParamspace), &stakingKeeper, feeCollectionKeeper,
+	)
+
+	ctx := sdk.NewContext(ms, abci.Header{Time: time.Unix(0, 0)}, false, log.NewTMLogger(os.Stdout))
+
+	mintKeeper.SetParams(ctx, DefaultParams())
+	mintKeeper.SetMinter(ctx, DefaultInitialMinter())
+
+	return testInput{ctx, cdc, mintKeeper}
+}
diff --git a/x/mock/app.go b/x/mock/app.go
index 3e24bee0d..d576dde8e 100644
--- a/x/mock/app.go
+++ b/x/mock/app.go
@@ -62,7 +62,7 @@ func NewApp() *App {
 		KeyFeeCollection: sdk.NewKVStoreKey("fee"),
 		KeyParams:        sdk.NewKVStoreKey("params"),
 		TKeyParams:       sdk.NewTransientStoreKey("transient_params"),
-		TotalCoinsSupply: sdk.Coins{},
+		TotalCoinsSupply: sdk.NewCoins(),
 	}
 
 	app.ParamsKeeper = params.NewKeeper(app.Cdc, app.KeyParams, app.TKeyParams)
@@ -213,7 +213,7 @@ func SetGenesis(app *App, accs []auth.Account) {
 func GenTx(msgs []sdk.Msg, accnums []uint64, seq []uint64, priv ...crypto.PrivKey) auth.StdTx {
 	// Make the transaction free
 	fee := auth.StdFee{
-		Amount: sdk.Coins{sdk.NewInt64Coin("foocoin", 0)},
+		Amount: sdk.NewCoins(sdk.NewInt64Coin("foocoin", 0)),
 		Gas:    100000,
 	}
 
diff --git a/x/mock/app_test.go b/x/mock/app_test.go
index a10116838..7a2b6adfd 100644
--- a/x/mock/app_test.go
+++ b/x/mock/app_test.go
@@ -60,15 +60,17 @@ func TestCheckAndDeliverGenTx(t *testing.T) {
 	acct := mApp.AccountKeeper.GetAccount(ctxCheck, addrs[0])
 	require.Equal(t, accs[0], acct.(*auth.BaseAccount))
 
+	header := abci.Header{Height: mApp.LastBlockHeight() + 1}
 	SignCheckDeliver(
-		t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{msg},
+		t, mApp.Cdc, mApp.BaseApp, header, []sdk.Msg{msg},
 		[]uint64{accs[0].GetAccountNumber()}, []uint64{accs[0].GetSequence()},
 		true, true, privKeys[0],
 	)
 
 	// Signing a tx with the wrong privKey should result in an auth error
+	header = abci.Header{Height: mApp.LastBlockHeight() + 1}
 	res := SignCheckDeliver(
-		t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{msg},
+		t, mApp.Cdc, mApp.BaseApp, header, []sdk.Msg{msg},
 		[]uint64{accs[1].GetAccountNumber()}, []uint64{accs[1].GetSequence() + 1},
 		true, false, privKeys[1],
 	)
@@ -77,8 +79,9 @@ func TestCheckAndDeliverGenTx(t *testing.T) {
 	require.Equal(t, sdk.CodespaceRoot, res.Codespace)
 
 	// Resigning the tx with the correct privKey should result in an OK result
+	header = abci.Header{Height: mApp.LastBlockHeight() + 1}
 	SignCheckDeliver(
-		t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{msg},
+		t, mApp.Cdc, mApp.BaseApp, header, []sdk.Msg{msg},
 		[]uint64{accs[0].GetAccountNumber()}, []uint64{accs[0].GetSequence() + 1},
 		true, true, privKeys[0],
 	)
diff --git a/x/mock/simulation/operation.go b/x/mock/simulation/operation.go
deleted file mode 100644
index 00237e03e..000000000
--- a/x/mock/simulation/operation.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package simulation
-
-import (
-	"math/rand"
-	"sort"
-	"time"
-
-	"github.com/cosmos/cosmos-sdk/baseapp"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-)
-
-// Operation runs a state machine transition, and ensures the transition
-// happened as expected.  The operation could be running and testing a fuzzed
-// transaction, or doing the same for a message.
-//
-// For ease of debugging, an operation returns a descriptive message "action",
-// which details what this fuzzed state machine transition actually did.
-//
-// Operations can optionally provide a list of "FutureOperations" to run later
-// These will be ran at the beginning of the corresponding block.
-type Operation func(r *rand.Rand, app *baseapp.BaseApp,
-	ctx sdk.Context, accounts []Account, event func(string)) (
-	action string, futureOps []FutureOperation, err error)
-
-// queue of operations
-type OperationQueue map[int][]Operation
-
-func newOperationQueue() OperationQueue {
-	operationQueue := make(OperationQueue)
-	return operationQueue
-}
-
-// adds all future operations into the operation queue.
-func queueOperations(queuedOps OperationQueue,
-	queuedTimeOps []FutureOperation, futureOps []FutureOperation) {
-
-	if futureOps == nil {
-		return
-	}
-
-	for _, futureOp := range futureOps {
-		if futureOp.BlockHeight != 0 {
-			if val, ok := queuedOps[futureOp.BlockHeight]; ok {
-				queuedOps[futureOp.BlockHeight] = append(val, futureOp.Op)
-			} else {
-				queuedOps[futureOp.BlockHeight] = []Operation{futureOp.Op}
-			}
-			continue
-		}
-
-		// TODO: Replace with proper sorted data structure, so don't have the
-		// copy entire slice
-		index := sort.Search(
-			len(queuedTimeOps),
-			func(i int) bool {
-				return queuedTimeOps[i].BlockTime.After(futureOp.BlockTime)
-			},
-		)
-		queuedTimeOps = append(queuedTimeOps, FutureOperation{})
-		copy(queuedTimeOps[index+1:], queuedTimeOps[index:])
-		queuedTimeOps[index] = futureOp
-	}
-}
-
-//________________________________________________________________________
-
-// FutureOperation is an operation which will be ran at the beginning of the
-// provided BlockHeight. If both a BlockHeight and BlockTime are specified, it
-// will use the BlockHeight. In the (likely) event that multiple operations
-// are queued at the same block height, they will execute in a FIFO pattern.
-type FutureOperation struct {
-	BlockHeight int
-	BlockTime   time.Time
-	Op          Operation
-}
-
-//________________________________________________________________________
-
-// WeightedOperation is an operation with associated weight.
-// This is used to bias the selection operation within the simulator.
-type WeightedOperation struct {
-	Weight int
-	Op     Operation
-}
-
-// WeightedOperations is the group of all weighted operations to simulate.
-type WeightedOperations []WeightedOperation
-
-func (ops WeightedOperations) totalWeight() int {
-	totalOpWeight := 0
-	for _, op := range ops {
-		totalOpWeight += op.Weight
-	}
-	return totalOpWeight
-}
-
-type selectOpFn func(r *rand.Rand) Operation
-
-func (ops WeightedOperations) getSelectOpFn() selectOpFn {
-	totalOpWeight := ops.totalWeight()
-	return func(r *rand.Rand) Operation {
-		x := r.Intn(totalOpWeight)
-		for i := 0; i < len(ops); i++ {
-			if x <= ops[i].Weight {
-				return ops[i].Op
-			}
-			x -= ops[i].Weight
-		}
-		// shouldn't happen
-		return ops[0].Op
-	}
-}
diff --git a/x/mock/test_utils.go b/x/mock/test_utils.go
index 9032d1f3d..2b5978823 100644
--- a/x/mock/test_utils.go
+++ b/x/mock/test_utils.go
@@ -72,9 +72,10 @@ func CheckGenTx(
 // block commitment with the given transaction. A test assertion is made using
 // the parameter 'expPass' against the result. A corresponding result is
 // returned.
-func SignCheckDeliver(t *testing.T, cdc *codec.Codec, app *baseapp.BaseApp,
-	msgs []sdk.Msg, accNums, seq []uint64, expSimPass, expPass bool,
-	priv ...crypto.PrivKey) sdk.Result {
+func SignCheckDeliver(
+	t *testing.T, cdc *codec.Codec, app *baseapp.BaseApp, header abci.Header, msgs []sdk.Msg,
+	accNums, seq []uint64, expSimPass, expPass bool, priv ...crypto.PrivKey,
+) sdk.Result {
 
 	tx := GenTx(msgs, accNums, seq, priv...)
 
@@ -91,7 +92,7 @@ func SignCheckDeliver(t *testing.T, cdc *codec.Codec, app *baseapp.BaseApp,
 	}
 
 	// Simulate a sending a transaction and committing a block
-	app.BeginBlock(abci.RequestBeginBlock{})
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
 	res = app.Deliver(tx)
 
 	if expPass {
diff --git a/x/mock/simulation/account.go b/x/simulation/account.go
similarity index 100%
rename from x/mock/simulation/account.go
rename to x/simulation/account.go
diff --git a/x/mock/simulation/doc.go b/x/simulation/doc.go
similarity index 100%
rename from x/mock/simulation/doc.go
rename to x/simulation/doc.go
diff --git a/x/mock/simulation/event_stats.go b/x/simulation/event_stats.go
similarity index 100%
rename from x/mock/simulation/event_stats.go
rename to x/simulation/event_stats.go
diff --git a/x/simulation/log.go b/x/simulation/log.go
new file mode 100644
index 000000000..9bdb76fde
--- /dev/null
+++ b/x/simulation/log.go
@@ -0,0 +1,70 @@
+package simulation
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"time"
+)
+
+// log writter
+type LogWriter interface {
+	AddEntry(OperationEntry)
+	PrintLogs()
+}
+
+// LogWriter - return a dummy or standard log writer given the testingmode
+func NewLogWriter(testingmode bool) LogWriter {
+	if !testingmode {
+		return &DummyLogWriter{}
+	}
+	return &StandardLogWriter{}
+}
+
+// log writter
+type StandardLogWriter struct {
+	OpEntries []OperationEntry `json:"op_entries"`
+}
+
+// add an entry to the log writter
+func (lw *StandardLogWriter) AddEntry(opEntry OperationEntry) {
+	lw.OpEntries = append(lw.OpEntries, opEntry)
+}
+
+// PrintLogs - print the logs to a simulation file
+func (lw *StandardLogWriter) PrintLogs() {
+	f := createLogFile()
+	for i := 0; i < len(lw.OpEntries); i++ {
+		writeEntry := fmt.Sprintf("%s\n", (lw.OpEntries[i]).MustMarshal())
+		_, err := f.WriteString(writeEntry)
+		if err != nil {
+			panic("Failed to write logs to file")
+		}
+	}
+}
+
+func createLogFile() *os.File {
+	var f *os.File
+	fileName := fmt.Sprintf("%s.log", time.Now().Format("2006-01-02_15:04:05"))
+
+	folderPath := os.ExpandEnv("$HOME/.gaiad/simulations")
+	filePath := path.Join(folderPath, fileName)
+
+	err := os.MkdirAll(folderPath, os.ModePerm)
+	if err != nil {
+		panic(err)
+	}
+	f, _ = os.Create(filePath)
+	fmt.Printf("Logs to writing to %s\n", filePath)
+	return f
+}
+
+//_____________________
+// dummy log writter
+type DummyLogWriter struct{}
+
+// do nothing
+func (lw *DummyLogWriter) AddEntry(_ OperationEntry) {}
+
+// do nothing
+func (lw *DummyLogWriter) PrintLogs() {}
diff --git a/x/mock/simulation/mock_tendermint.go b/x/simulation/mock_tendermint.go
similarity index 100%
rename from x/mock/simulation/mock_tendermint.go
rename to x/simulation/mock_tendermint.go
diff --git a/x/simulation/operation.go b/x/simulation/operation.go
new file mode 100644
index 000000000..31bedc758
--- /dev/null
+++ b/x/simulation/operation.go
@@ -0,0 +1,251 @@
+package simulation
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"sort"
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// Operation runs a state machine transition, and ensures the transition
+// happened as expected.  The operation could be running and testing a fuzzed
+// transaction, or doing the same for a message.
+//
+// For ease of debugging, an operation returns a descriptive message "action",
+// which details what this fuzzed state machine transition actually did.
+//
+// Operations can optionally provide a list of "FutureOperations" to run later
+// These will be ran at the beginning of the corresponding block.
+type Operation func(r *rand.Rand, app *baseapp.BaseApp,
+	ctx sdk.Context, accounts []Account) (
+	OperationMsg OperationMsg, futureOps []FutureOperation, err error)
+
+// entry kinds for use within OperationEntry
+const (
+	BeginBlockEntryKind  = "begin_block"
+	EndBlockEntryKind    = "end_block"
+	MsgEntryKind         = "msg"
+	QueuedsgMsgEntryKind = "queued_msg"
+)
+
+// OperationEntry - an operation entry for logging (ex. BeginBlock, EndBlock, XxxMsg, etc)
+type OperationEntry struct {
+	EntryKind string          `json:"entry_kind"`
+	Height    int64           `json:"height"`
+	Order     int64           `json:"order"`
+	Operation json.RawMessage `json:"operation"`
+}
+
+// BeginBlockEntry - operation entry for begin block
+func BeginBlockEntry(height int64) OperationEntry {
+	return OperationEntry{
+		EntryKind: BeginBlockEntryKind,
+		Height:    height,
+		Order:     -1,
+		Operation: nil,
+	}
+}
+
+// EndBlockEntry - operation entry for end block
+func EndBlockEntry(height int64) OperationEntry {
+	return OperationEntry{
+		EntryKind: EndBlockEntryKind,
+		Height:    height,
+		Order:     -1,
+		Operation: nil,
+	}
+}
+
+// MsgEntry - operation entry for standard msg
+func MsgEntry(height int64, opMsg OperationMsg, order int64) OperationEntry {
+	return OperationEntry{
+		EntryKind: MsgEntryKind,
+		Height:    height,
+		Order:     order,
+		Operation: opMsg.MustMarshal(),
+	}
+}
+
+// MsgEntry - operation entry for queued msg
+func QueuedMsgEntry(height int64, opMsg OperationMsg) OperationEntry {
+	return OperationEntry{
+		EntryKind: QueuedsgMsgEntryKind,
+		Height:    height,
+		Order:     -1,
+		Operation: opMsg.MustMarshal(),
+	}
+}
+
+// OperationEntry - log entry text for this operation entry
+func (oe OperationEntry) MustMarshal() json.RawMessage {
+	out, err := json.Marshal(oe)
+	if err != nil {
+		panic(err)
+	}
+	return out
+}
+
+//_____________________________________________________________________
+
+// OperationMsg - structure for operation output
+type OperationMsg struct {
+	Route   string          `json:"route"`
+	Name    string          `json:"name"`
+	Comment string          `json:"comment"`
+	OK      bool            `json:"ok"`
+	Msg     json.RawMessage `json:"msg"`
+}
+
+// OperationMsg - create a new operation message from sdk.Msg
+func NewOperationMsg(msg sdk.Msg, ok bool, comment string) OperationMsg {
+
+	return OperationMsg{
+		Route:   msg.Route(),
+		Name:    msg.Type(),
+		Comment: comment,
+		OK:      ok,
+		Msg:     msg.GetSignBytes(),
+	}
+}
+
+// OperationMsg - create a new operation message from raw input
+func NewOperationMsgBasic(route, name, comment string, ok bool, msg []byte) OperationMsg {
+	return OperationMsg{
+		Route:   route,
+		Name:    name,
+		Comment: comment,
+		OK:      ok,
+		Msg:     msg,
+	}
+}
+
+// NoOpMsg - create a no-operation message
+func NoOpMsg() OperationMsg {
+	return OperationMsg{
+		Route:   "",
+		Name:    "no-operation",
+		Comment: "",
+		OK:      false,
+		Msg:     nil,
+	}
+}
+
+// log entry text for this operation msg
+func (om OperationMsg) String() string {
+	out, err := json.Marshal(om)
+	if err != nil {
+		panic(err)
+	}
+	return string(out)
+}
+
+// Marshal the operation msg, panic on error
+func (om OperationMsg) MustMarshal() json.RawMessage {
+	out, err := json.Marshal(om)
+	if err != nil {
+		panic(err)
+	}
+	return out
+}
+
+// add event for event stats
+func (om OperationMsg) LogEvent(eventLogger func(string)) {
+	pass := "ok"
+	if !om.OK {
+		pass = "failure"
+	}
+	eventLogger(fmt.Sprintf("%v/%v/%v", om.Route, om.Name, pass))
+}
+
+// queue of operations
+type OperationQueue map[int][]Operation
+
+func newOperationQueue() OperationQueue {
+	operationQueue := make(OperationQueue)
+	return operationQueue
+}
+
+// adds all future operations into the operation queue.
+func queueOperations(queuedOps OperationQueue,
+	queuedTimeOps []FutureOperation, futureOps []FutureOperation) {
+
+	if futureOps == nil {
+		return
+	}
+
+	for _, futureOp := range futureOps {
+		if futureOp.BlockHeight != 0 {
+			if val, ok := queuedOps[futureOp.BlockHeight]; ok {
+				queuedOps[futureOp.BlockHeight] = append(val, futureOp.Op)
+			} else {
+				queuedOps[futureOp.BlockHeight] = []Operation{futureOp.Op}
+			}
+			continue
+		}
+
+		// TODO: Replace with proper sorted data structure, so don't have the
+		// copy entire slice
+		index := sort.Search(
+			len(queuedTimeOps),
+			func(i int) bool {
+				return queuedTimeOps[i].BlockTime.After(futureOp.BlockTime)
+			},
+		)
+		queuedTimeOps = append(queuedTimeOps, FutureOperation{})
+		copy(queuedTimeOps[index+1:], queuedTimeOps[index:])
+		queuedTimeOps[index] = futureOp
+	}
+}
+
+//________________________________________________________________________
+
+// FutureOperation is an operation which will be ran at the beginning of the
+// provided BlockHeight. If both a BlockHeight and BlockTime are specified, it
+// will use the BlockHeight. In the (likely) event that multiple operations
+// are queued at the same block height, they will execute in a FIFO pattern.
+type FutureOperation struct {
+	BlockHeight int
+	BlockTime   time.Time
+	Op          Operation
+}
+
+//________________________________________________________________________
+
+// WeightedOperation is an operation with associated weight.
+// This is used to bias the selection operation within the simulator.
+type WeightedOperation struct {
+	Weight int
+	Op     Operation
+}
+
+// WeightedOperations is the group of all weighted operations to simulate.
+type WeightedOperations []WeightedOperation
+
+func (ops WeightedOperations) totalWeight() int {
+	totalOpWeight := 0
+	for _, op := range ops {
+		totalOpWeight += op.Weight
+	}
+	return totalOpWeight
+}
+
+type selectOpFn func(r *rand.Rand) Operation
+
+func (ops WeightedOperations) getSelectOpFn() selectOpFn {
+	totalOpWeight := ops.totalWeight()
+	return func(r *rand.Rand) Operation {
+		x := r.Intn(totalOpWeight)
+		for i := 0; i < len(ops); i++ {
+			if x <= ops[i].Weight {
+				return ops[i].Op
+			}
+			x -= ops[i].Weight
+		}
+		// shouldn't happen
+		return ops[0].Op
+	}
+}
diff --git a/x/mock/simulation/params.go b/x/simulation/params.go
similarity index 100%
rename from x/mock/simulation/params.go
rename to x/simulation/params.go
diff --git a/x/mock/simulation/rand_util.go b/x/simulation/rand_util.go
similarity index 89%
rename from x/mock/simulation/rand_util.go
rename to x/simulation/rand_util.go
index 1a5e4566f..a9b32ca48 100644
--- a/x/mock/simulation/rand_util.go
+++ b/x/simulation/rand_util.go
@@ -6,7 +6,6 @@ import (
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/mock"
 )
 
 const (
@@ -66,15 +65,6 @@ func RandomDecAmount(r *rand.Rand, max sdk.Dec) sdk.Dec {
 	return sdk.NewDecFromBigIntWithPrec(randInt, sdk.Precision)
 }
 
-// RandomSetGenesis wraps mock.RandomSetGenesis, but using simulation accounts
-func RandomSetGenesis(r *rand.Rand, app *mock.App, accs []Account, denoms []string) {
-	addrs := make([]sdk.AccAddress, len(accs))
-	for i := 0; i < len(accs); i++ {
-		addrs[i] = accs[i].Address
-	}
-	mock.RandomSetGenesis(r, app, addrs, denoms)
-}
-
 // RandTimestamp generates a random timestamp
 func RandTimestamp(r *rand.Rand) time.Time {
 	// json.Marshal breaks for timestamps greater with year greater than 9999
diff --git a/x/mock/simulation/simulate.go b/x/simulation/simulate.go
similarity index 79%
rename from x/mock/simulation/simulate.go
rename to x/simulation/simulate.go
index e67bddc3c..3eb25ccbc 100644
--- a/x/mock/simulation/simulate.go
+++ b/x/simulation/simulate.go
@@ -7,7 +7,6 @@ import (
 	"os"
 	"os/signal"
 	"runtime/debug"
-	"strings"
 	"syscall"
 	"testing"
 	"time"
@@ -24,11 +23,11 @@ type AppStateFn func(r *rand.Rand, accs []Account, genesisTimestamp time.Time) (
 // Simulate tests application by sending random messages.
 func Simulate(t *testing.T, app *baseapp.BaseApp,
 	appStateFn AppStateFn, ops WeightedOperations,
-	invariants sdk.Invariants, numBlocks int, blockSize int, commit bool) (bool, error) {
+	invariants sdk.Invariants, numBlocks, blockSize int, commit, lean bool) (bool, error) {
 
 	time := time.Now().UnixNano()
 	return SimulateFromSeed(t, app, appStateFn, time, ops,
-		invariants, numBlocks, blockSize, commit)
+		invariants, numBlocks, blockSize, commit, lean)
 }
 
 // initialize the chain for the simulation
@@ -55,7 +54,7 @@ func initChain(
 func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 	appStateFn AppStateFn, seed int64, ops WeightedOperations,
 	invariants sdk.Invariants,
-	numBlocks int, blockSize int, commit bool) (stopEarly bool, simError error) {
+	numBlocks, blockSize int, commit, lean bool) (stopEarly bool, simError error) {
 
 	// in case we have to end early, don't os.Exit so that we can run cleanup code.
 	testingMode, t, b := getTestingMode(tb)
@@ -110,16 +109,13 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 	// These are operations which have been queued by previous operations
 	operationQueue := newOperationQueue()
 	timeOperationQueue := []FutureOperation{}
-	var blockLogBuilders []*strings.Builder
 
-	if testingMode {
-		blockLogBuilders = make([]*strings.Builder, numBlocks)
-	}
-	displayLogs := logPrinter(testingMode, blockLogBuilders)
+	logWriter := NewLogWriter(testingMode)
+
 	blockSimulator := createBlockSimulator(
 		testingMode, tb, t, params, eventStats.tally, invariants,
 		ops, operationQueue, timeOperationQueue,
-		numBlocks, blockSize, displayLogs)
+		numBlocks, blockSize, logWriter, lean)
 
 	if !testingMode {
 		b.ResetTimer()
@@ -130,7 +126,7 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 				fmt.Println("Panic with err\n", r)
 				stackTrace := string(debug.Stack())
 				fmt.Println(stackTrace)
-				displayLogs()
+				logWriter.PrintLogs()
 				simError = fmt.Errorf(
 					"Simulation halted due to panic on block %d",
 					header.Height)
@@ -139,46 +135,40 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 	}
 
 	// TODO split up the contents of this for loop into new functions
-	for i := 0; i < numBlocks && !stopEarly; i++ {
+	for height := 1; height <= numBlocks && !stopEarly; height++ {
 
 		// Log the header time for future lookup
 		pastTimes = append(pastTimes, header.Time)
 		pastVoteInfos = append(pastVoteInfos, request.LastCommitInfo.Votes)
 
-		// Construct log writer
-		logWriter := addLogMessage(testingMode, blockLogBuilders, i)
-
 		// Run the BeginBlock handler
-		logWriter("BeginBlock")
+		logWriter.AddEntry(BeginBlockEntry(int64(height)))
 		app.BeginBlock(request)
 
 		if testingMode {
-			assertAllInvariants(t, app, invariants, "BeginBlock", displayLogs)
+			assertAllInvariants(t, app, invariants, "BeginBlock", logWriter)
 		}
 
 		ctx := app.NewContext(false, header)
 
 		// Run queued operations. Ignores blocksize if blocksize is too small
-		logWriter("Queued operations")
 		numQueuedOpsRan := runQueuedOperations(
 			operationQueue, int(header.Height),
-			tb, r, app, ctx, accs, logWriter,
-			displayLogs, eventStats.tally)
+			tb, r, app, ctx, accs, logWriter, eventStats.tally, lean)
 
 		numQueuedTimeOpsRan := runQueuedTimeOperations(
-			timeOperationQueue, header.Time,
-			tb, r, app, ctx, accs,
-			logWriter, displayLogs, eventStats.tally)
+			timeOperationQueue, int(header.Height), header.Time,
+			tb, r, app, ctx, accs, logWriter, eventStats.tally, lean)
 
 		if testingMode && onOperation {
-			assertAllInvariants(t, app, invariants, "QueuedOperations", displayLogs)
+			assertAllInvariants(t, app, invariants, "QueuedOperations", logWriter)
 		}
 
-		logWriter("Standard operations")
-		operations := blockSimulator(r, app, ctx, accs, header, logWriter)
+		// run standard operations
+		operations := blockSimulator(r, app, ctx, accs, header)
 		opCount += operations + numQueuedOpsRan + numQueuedTimeOpsRan
 		if testingMode {
-			assertAllInvariants(t, app, invariants, "StandardOperations", displayLogs)
+			assertAllInvariants(t, app, invariants, "StandardOperations", logWriter)
 		}
 
 		res := app.EndBlock(abci.RequestEndBlock{})
@@ -188,10 +178,10 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 		header.Time = header.Time.Add(
 			time.Duration(int64(r.Intn(int(timeDiff)))) * time.Second)
 		header.ProposerAddress = validators.randomProposer(r)
-		logWriter("EndBlock")
+		logWriter.AddEntry(EndBlockEntry(int64(height)))
 
 		if testingMode {
-			assertAllInvariants(t, app, invariants, "EndBlock", displayLogs)
+			assertAllInvariants(t, app, invariants, "EndBlock", logWriter)
 		}
 		if commit {
 			app.Commit()
@@ -231,21 +221,21 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 //______________________________________________________________________________
 
 type blockSimFn func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-	accounts []Account, header abci.Header, logWriter func(string)) (opCount int)
+	accounts []Account, header abci.Header) (opCount int)
 
 // Returns a function to simulate blocks. Written like this to avoid constant
 // parameters being passed everytime, to minimize memory overhead.
 func createBlockSimulator(testingMode bool, tb testing.TB, t *testing.T, params Params,
 	event func(string), invariants sdk.Invariants, ops WeightedOperations,
 	operationQueue OperationQueue, timeOperationQueue []FutureOperation,
-	totalNumBlocks int, avgBlockSize int, displayLogs func()) blockSimFn {
+	totalNumBlocks, avgBlockSize int, logWriter LogWriter, lean bool) blockSimFn {
 
-	var lastBlocksizeState = 0 // state for [4 * uniform distribution]
-	var blocksize int
+	lastBlocksizeState := 0 // state for [4 * uniform distribution]
+	blocksize := 0
 	selectOp := ops.getSelectOpFn()
 
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accounts []Account, header abci.Header, logWriter func(string)) (opCount int) {
+		accounts []Account, header abci.Header) (opCount int) {
 
 		fmt.Printf("\rSimulating... block %d/%d, operation %d/%d. ",
 			header.Height, totalNumBlocks, opCount, blocksize)
@@ -269,10 +259,13 @@ func createBlockSimulator(testingMode bool, tb testing.TB, t *testing.T, params
 			// NOTE: the Rand 'r' should not be used here.
 			opAndR := opAndRz[i]
 			op, r2 := opAndR.op, opAndR.rand
-			logUpdate, futureOps, err := op(r2, app, ctx, accounts, event)
-			logWriter(logUpdate)
+			opMsg, futureOps, err := op(r2, app, ctx, accounts)
+			opMsg.LogEvent(event)
+			if !lean || opMsg.OK {
+				logWriter.AddEntry(MsgEntry(header.Height, opMsg, int64(i)))
+			}
 			if err != nil {
-				displayLogs()
+				logWriter.PrintLogs()
 				tb.Fatalf("error on operation %d within block %d, %v",
 					header.Height, opCount, err)
 			}
@@ -280,8 +273,8 @@ func createBlockSimulator(testingMode bool, tb testing.TB, t *testing.T, params
 			queueOperations(operationQueue, timeOperationQueue, futureOps)
 			if testingMode {
 				if onOperation {
-					eventStr := fmt.Sprintf("operation: %v", logUpdate)
-					assertAllInvariants(t, app, invariants, eventStr, displayLogs)
+					eventStr := fmt.Sprintf("operation: %v", opMsg.String())
+					assertAllInvariants(t, app, invariants, eventStr, logWriter)
 				}
 				if opCount%50 == 0 {
 					fmt.Printf("\rSimulating... block %d/%d, operation %d/%d. ",
@@ -297,8 +290,7 @@ func createBlockSimulator(testingMode bool, tb testing.TB, t *testing.T, params
 // nolint: errcheck
 func runQueuedOperations(queueOps map[int][]Operation,
 	height int, tb testing.TB, r *rand.Rand, app *baseapp.BaseApp,
-	ctx sdk.Context, accounts []Account, logWriter func(string),
-	displayLogs func(), tallyEvent func(string)) (numOpsRan int) {
+	ctx sdk.Context, accounts []Account, logWriter LogWriter, tallyEvent func(string), lean bool) (numOpsRan int) {
 
 	queuedOp, ok := queueOps[height]
 	if !ok {
@@ -311,10 +303,13 @@ func runQueuedOperations(queueOps map[int][]Operation,
 		// For now, queued operations cannot queue more operations.
 		// If a need arises for us to support queued messages to queue more messages, this can
 		// be changed.
-		logUpdate, _, err := queuedOp[i](r, app, ctx, accounts, tallyEvent)
-		logWriter(logUpdate)
+		opMsg, _, err := queuedOp[i](r, app, ctx, accounts)
+		opMsg.LogEvent(tallyEvent)
+		if !lean || opMsg.OK {
+			logWriter.AddEntry((QueuedMsgEntry(int64(height), opMsg)))
+		}
 		if err != nil {
-			displayLogs()
+			logWriter.PrintLogs()
 			tb.FailNow()
 		}
 	}
@@ -323,9 +318,9 @@ func runQueuedOperations(queueOps map[int][]Operation,
 }
 
 func runQueuedTimeOperations(queueOps []FutureOperation,
-	currentTime time.Time, tb testing.TB, r *rand.Rand,
+	height int, currentTime time.Time, tb testing.TB, r *rand.Rand,
 	app *baseapp.BaseApp, ctx sdk.Context, accounts []Account,
-	logWriter func(string), displayLogs func(), tallyEvent func(string)) (numOpsRan int) {
+	logWriter LogWriter, tallyEvent func(string), lean bool) (numOpsRan int) {
 
 	numOpsRan = 0
 	for len(queueOps) > 0 && currentTime.After(queueOps[0].BlockTime) {
@@ -333,10 +328,13 @@ func runQueuedTimeOperations(queueOps []FutureOperation,
 		// For now, queued operations cannot queue more operations.
 		// If a need arises for us to support queued messages to queue more messages, this can
 		// be changed.
-		logUpdate, _, err := queueOps[0].Op(r, app, ctx, accounts, tallyEvent)
-		logWriter(logUpdate)
+		opMsg, _, err := queueOps[0].Op(r, app, ctx, accounts)
+		opMsg.LogEvent(tallyEvent)
+		if !lean || opMsg.OK {
+			logWriter.AddEntry(QueuedMsgEntry(int64(height), opMsg))
+		}
 		if err != nil {
-			displayLogs()
+			logWriter.PrintLogs()
 			tb.FailNow()
 		}
 
diff --git a/x/mock/simulation/transition_matrix.go b/x/simulation/transition_matrix.go
similarity index 100%
rename from x/mock/simulation/transition_matrix.go
rename to x/simulation/transition_matrix.go
diff --git a/x/mock/simulation/util.go b/x/simulation/util.go
similarity index 60%
rename from x/mock/simulation/util.go
rename to x/simulation/util.go
index 962dbfe43..14df0f6c6 100644
--- a/x/mock/simulation/util.go
+++ b/x/simulation/util.go
@@ -3,10 +3,7 @@ package simulation
 import (
 	"fmt"
 	"math/rand"
-	"os"
-	"strings"
 	"testing"
-	"time"
 
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -15,14 +12,14 @@ import (
 
 // assertAll asserts the all invariants against application state
 func assertAllInvariants(t *testing.T, app *baseapp.BaseApp, invs sdk.Invariants,
-	event string, displayLogs func()) {
+	event string, logWriter LogWriter) {
 
 	ctx := app.NewContext(false, abci.Header{Height: app.LastBlockHeight() + 1})
 
 	for i := 0; i < len(invs); i++ {
 		if err := invs[i](ctx); err != nil {
 			fmt.Printf("Invariants broken after %s\n%s\n", event, err.Error())
-			displayLogs()
+			logWriter.PrintLogs()
 			t.Fatal()
 		}
 	}
@@ -36,67 +33,7 @@ func getTestingMode(tb testing.TB) (testingMode bool, t *testing.T, b *testing.B
 	} else {
 		b = tb.(*testing.B)
 	}
-	return
-}
-
-// Builds a function to add logs for this particular block
-func addLogMessage(testingmode bool,
-	blockLogBuilders []*strings.Builder, height int) func(string) {
-
-	if !testingmode {
-		return func(_ string) {}
-	}
-
-	blockLogBuilders[height] = &strings.Builder{}
-	return func(x string) {
-		(*blockLogBuilders[height]).WriteString(x)
-		(*blockLogBuilders[height]).WriteString("\n")
-	}
-}
-
-// Creates a function to print out the logs
-func logPrinter(testingmode bool, logs []*strings.Builder) func() {
-	if !testingmode {
-		return func() {}
-	}
-
-	return func() {
-		numLoggers := 0
-		for i := 0; i < len(logs); i++ {
-			// We're passed the last created block
-			if logs[i] == nil {
-				numLoggers = i
-				break
-			}
-		}
-
-		var f *os.File
-		if numLoggers > 10 {
-			fileName := fmt.Sprintf("simulation_log_%s.txt",
-				time.Now().Format("2006-01-02 15:04:05"))
-			fmt.Printf("Too many logs to display, instead writing to %s\n",
-				fileName)
-			f, _ = os.Create(fileName)
-		}
-
-		for i := 0; i < numLoggers; i++ {
-			if f == nil {
-				fmt.Printf("Begin block %d\n", i+1)
-				fmt.Println((*logs[i]).String())
-				continue
-			}
-
-			_, err := f.WriteString(fmt.Sprintf("Begin block %d\n", i+1))
-			if err != nil {
-				panic("Failed to write logs to file")
-			}
-
-			_, err = f.WriteString((*logs[i]).String())
-			if err != nil {
-				panic("Failed to write logs to file")
-			}
-		}
-	}
+	return testingMode, t, b
 }
 
 // getBlockSize returns a block size as determined from the transition matrix.
diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go
index 6f15e4aee..94d53f588 100644
--- a/x/slashing/app_test.go
+++ b/x/slashing/app_test.go
@@ -111,9 +111,13 @@ func TestSlashingMsgs(t *testing.T) {
 	createValidatorMsg := staking.NewMsgCreateValidator(
 		sdk.ValAddress(addr1), priv1.PubKey(), bondCoin, description, commission, sdk.OneInt(),
 	)
-	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, []sdk.Msg{createValidatorMsg}, []uint64{0}, []uint64{0}, true, true, priv1)
+
+	header := abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{createValidatorMsg}, []uint64{0}, []uint64{0}, true, true, priv1)
 	mock.CheckBalance(t, mapp, addr1, sdk.Coins{genCoin.Sub(bondCoin)})
-	mapp.BeginBlock(abci.RequestBeginBlock{})
+
+	header = abci.Header{Height: mapp.LastBlockHeight() + 1}
+	mapp.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 	validator := checkValidator(t, mapp, stakingKeeper, addr1, true)
 	require.Equal(t, sdk.ValAddress(addr1), validator.OperatorAddress)
@@ -125,7 +129,8 @@ func TestSlashingMsgs(t *testing.T) {
 	checkValidatorSigningInfo(t, mapp, keeper, sdk.ConsAddress(addr1), false)
 
 	// unjail should fail with unknown validator
-	res := mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, []sdk.Msg{unjailMsg}, []uint64{0}, []uint64{1}, false, false, priv1)
+	header = abci.Header{Height: mapp.LastBlockHeight() + 1}
+	res := mock.SignCheckDeliver(t, mapp.Cdc, mapp.BaseApp, header, []sdk.Msg{unjailMsg}, []uint64{0}, []uint64{1}, false, false, priv1)
 	require.EqualValues(t, CodeValidatorNotJailed, res.Code)
 	require.EqualValues(t, DefaultCodespace, res.Codespace)
 }
diff --git a/x/slashing/client/rest/query.go b/x/slashing/client/rest/query.go
index 2f037e5fb..3c4afdd00 100644
--- a/x/slashing/client/rest/query.go
+++ b/x/slashing/client/rest/query.go
@@ -2,15 +2,14 @@ package rest
 
 import (
 	"fmt"
-	"net/http"
-
-	"github.com/gorilla/mux"
-
 	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/client/rpc"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/rest"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
+	"github.com/gorilla/mux"
+	"net/http"
 )
 
 func registerQueryRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec) {
@@ -19,6 +18,11 @@ func registerQueryRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Co
 		signingInfoHandlerFn(cliCtx, slashing.StoreKey, cdc),
 	).Methods("GET")
 
+	r.HandleFunc(
+		"/slashing/signing_infos",
+		signingInfoHandlerListFn(cliCtx, slashing.StoreKey, cdc),
+	).Methods("GET").Queries("page", "{page}", "limit", "{limit}")
+
 	r.HandleFunc(
 		"/slashing/parameters",
 		queryParamsHandlerFn(cdc, cliCtx),
@@ -26,39 +30,79 @@ func registerQueryRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Co
 }
 
 // http request handler to query signing info
-// nolint: unparam
 func signingInfoHandlerFn(cliCtx context.CLIContext, storeName string, cdc *codec.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		vars := mux.Vars(r)
-
 		pk, err := sdk.GetConsPubKeyBech32(vars["validatorPubKey"])
 		if err != nil {
 			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
 			return
 		}
 
-		key := slashing.GetValidatorSigningInfoKey(sdk.ConsAddress(pk.Address()))
+		signingInfo, code, err := getSigningInfo(cliCtx, storeName, cdc, pk.Address())
 
-		res, err := cliCtx.QueryStore(key, storeName)
 		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			rest.WriteErrorResponse(w, code, err.Error())
 			return
 		}
 
-		if len(res) == 0 {
+		if code == http.StatusNoContent {
 			w.WriteHeader(http.StatusNoContent)
 			return
 		}
 
-		var signingInfo slashing.ValidatorSigningInfo
+		rest.PostProcessResponse(w, cdc, signingInfo, cliCtx.Indent)
+	}
+}
 
-		err = cdc.UnmarshalBinaryLengthPrefixed(res, &signingInfo)
+// http request handler to query signing info
+func signingInfoHandlerListFn(cliCtx context.CLIContext, storeName string, cdc *codec.Codec) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var signingInfoList []slashing.ValidatorSigningInfo
+
+		_, page, limit, err := rest.ParseHTTPArgs(r)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		height, err := rpc.GetChainHeight(cliCtx)
 		if err != nil {
 			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 
-		rest.PostProcessResponse(w, cdc, signingInfo, cliCtx.Indent)
+		validators, err := rpc.GetValidators(cliCtx, &height)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		if len(validators.Validators) == 0 {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+
+		// TODO: this should happen when querying Validators from RPC,
+		//  as soon as it's available this is not needed anymore
+		// parameter page is (page-1) because ParseHTTPArgs starts with page 1, where our array start with 0
+		start, end := adjustPagination(uint(len(validators.Validators)), uint(page)-1, uint(limit))
+		for _, validator := range validators.Validators[start:end] {
+			address := validator.Address
+			signingInfo, code, err := getSigningInfo(cliCtx, storeName, cdc, address)
+			if err != nil {
+				rest.WriteErrorResponse(w, code, err.Error())
+				return
+			}
+			signingInfoList = append(signingInfoList, signingInfo)
+		}
+
+		if len(signingInfoList) == 0 {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+
+		rest.PostProcessResponse(w, cdc, signingInfoList, cliCtx.Indent)
 	}
 }
 
@@ -75,3 +119,48 @@ func queryParamsHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.Hand
 		rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
 	}
 }
+
+func getSigningInfo(cliCtx context.CLIContext, storeName string, cdc *codec.Codec, address []byte) (signingInfo slashing.ValidatorSigningInfo, code int, err error) {
+	key := slashing.GetValidatorSigningInfoKey(sdk.ConsAddress(address))
+
+	res, err := cliCtx.QueryStore(key, storeName)
+	if err != nil {
+		code = http.StatusInternalServerError
+		return
+	}
+
+	if len(res) == 0 {
+		code = http.StatusNoContent
+		return
+	}
+
+	err = cdc.UnmarshalBinaryLengthPrefixed(res, &signingInfo)
+	if err != nil {
+		code = http.StatusInternalServerError
+		return
+	}
+
+	return
+}
+
+// Adjust pagination with page starting from 0
+func adjustPagination(size, page, limit uint) (start uint, end uint) {
+	// If someone asks for pages bigger than our dataset, just return everything
+	if limit > size {
+		return 0, size
+	}
+
+	// Do pagination when healthy, fallback to 0
+	start = 0
+	if page*limit < size {
+		start = page * limit
+	}
+
+	// Do pagination only when healthy, fallback to len(dataset)
+	end = size
+	if start+limit <= size {
+		end = start + limit
+	}
+
+	return start, end
+}
diff --git a/x/slashing/client/rest/query_test.go b/x/slashing/client/rest/query_test.go
new file mode 100644
index 000000000..ad177c23b
--- /dev/null
+++ b/x/slashing/client/rest/query_test.go
@@ -0,0 +1,31 @@
+package rest
+
+import (
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestAdjustPagination(t *testing.T) {
+	type args struct {
+		s string
+	}
+	tests := []struct {
+		name  string
+		size  uint
+		page  uint
+		limit uint
+		start uint
+		end   uint
+	}{
+		{"Ok", 3, 0, 1, 0, 1},
+		{"Limit too big", 3, 1, 5, 0, 3},
+		{"Page over limit", 3, 2, 3, 0, 3},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			start, end := adjustPagination(tt.size, tt.page, tt.limit)
+			require.Equal(t, tt.start, start)
+			require.Equal(t, tt.end, end)
+		})
+	}
+}
diff --git a/x/slashing/handler.go b/x/slashing/handler.go
index fcc141a86..70a28089d 100644
--- a/x/slashing/handler.go
+++ b/x/slashing/handler.go
@@ -31,12 +31,12 @@ func handleMsgUnjail(ctx sdk.Context, msg MsgUnjail, k Keeper) sdk.Result {
 		return ErrMissingSelfDelegation(k.codespace).Result()
 	}
 
-	if validator.ShareTokens(selfDel.GetShares()).TruncateInt().LT(validator.GetMinSelfDelegation()) {
+	if validator.TokensFromShares(selfDel.GetShares()).TruncateInt().LT(validator.GetMinSelfDelegation()) {
 		return ErrSelfDelegationTooLowToUnjail(k.codespace).Result()
 	}
 
 	// cannot be unjailed if not jailed
-	if !validator.GetJailed() {
+	if !validator.IsJailed() {
 		return ErrValidatorNotJailed(k.codespace).Result()
 	}
 
diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go
index 07cf45001..18e03fba2 100644
--- a/x/slashing/handler_test.go
+++ b/x/slashing/handler_test.go
@@ -51,10 +51,11 @@ func TestCannotUnjailUnlessMeetMinSelfDelegation(t *testing.T) {
 		sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
 	)
 
-	undelegateMsg := staking.NewMsgUndelegate(sdk.AccAddress(addr), addr, sdk.OneDec())
+	unbondAmt := sdk.NewCoin(sk.GetParams(ctx).BondDenom, sdk.OneInt())
+	undelegateMsg := staking.NewMsgUndelegate(sdk.AccAddress(addr), addr, unbondAmt)
 	got = staking.NewHandler(sk)(ctx, undelegateMsg)
 
-	require.True(t, sk.Validator(ctx, addr).GetJailed())
+	require.True(t, sk.Validator(ctx, addr).IsJailed())
 
 	// assert non-jailed validator can't be unjailed
 	got = slh(ctx, NewMsgUnjail(addr))
@@ -92,10 +93,10 @@ func TestJailedValidatorDelegations(t *testing.T) {
 	got = staking.NewHandler(stakingKeeper)(ctx, msgDelegate)
 	require.True(t, got.IsOK(), "expected delegation to be ok, got %v", got)
 
-	unbondShares := bondAmount.ToDec()
+	unbondAmt := sdk.NewCoin(stakingKeeper.GetParams(ctx).BondDenom, bondAmount)
 
 	// unbond validator total self-delegations (which should jail the validator)
-	msgUndelegate := staking.NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, unbondShares)
+	msgUndelegate := staking.NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, unbondAmt)
 	got = staking.NewHandler(stakingKeeper)(ctx, msgUndelegate)
 	require.True(t, got.IsOK(), "expected begin unbonding validator msg to be ok, got: %v", got)
 
@@ -105,7 +106,7 @@ func TestJailedValidatorDelegations(t *testing.T) {
 	// verify validator still exists and is jailed
 	validator, found := stakingKeeper.GetValidator(ctx, valAddr)
 	require.True(t, found)
-	require.True(t, validator.GetJailed())
+	require.True(t, validator.IsJailed())
 
 	// verify the validator cannot unjail itself
 	got = NewHandler(slashingKeeper)(ctx, NewMsgUnjail(valAddr))
diff --git a/x/slashing/keeper.go b/x/slashing/keeper.go
index 8b8360492..35a357748 100644
--- a/x/slashing/keeper.go
+++ b/x/slashing/keeper.go
@@ -108,7 +108,7 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio
 
 	// Jail validator if not already jailed
 	// begin unbonding validator if not already unbonding (tombstone)
-	if !validator.GetJailed() {
+	if !validator.IsJailed() {
 		k.validatorSet.Jail(ctx, consAddr)
 	}
 
@@ -172,7 +172,7 @@ func (k Keeper) handleValidatorSignature(ctx sdk.Context, addr crypto.Address, p
 	// if we are past the minimum height and the validator has missed too many blocks, punish them
 	if height > minHeight && signInfo.MissedBlocksCounter > maxMissed {
 		validator := k.validatorSet.ValidatorByConsAddr(ctx, consAddr)
-		if validator != nil && !validator.GetJailed() {
+		if validator != nil && !validator.IsJailed() {
 
 			// Downtime confirmed: slash and jail the validator
 			logger.Info(fmt.Sprintf("Validator %s past min height of %d and below signed blocks threshold of %d",
diff --git a/x/slashing/keeper_test.go b/x/slashing/keeper_test.go
index 4dbc1e727..7b0bd1174 100644
--- a/x/slashing/keeper_test.go
+++ b/x/slashing/keeper_test.go
@@ -51,7 +51,7 @@ func TestHandleDoubleSign(t *testing.T) {
 	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), power)
 
 	// should be jailed
-	require.True(t, sk.Validator(ctx, operatorAddr).GetJailed())
+	require.True(t, sk.Validator(ctx, operatorAddr).IsJailed())
 
 	// tokens should be decreased
 	newTokens := sk.Validator(ctx, operatorAddr).GetTokens()
@@ -73,7 +73,10 @@ func TestHandleDoubleSign(t *testing.T) {
 
 	// Should be able to unbond now
 	del, _ := sk.GetDelegation(ctx, sdk.AccAddress(operatorAddr), operatorAddr)
-	msgUnbond := staking.NewMsgUndelegate(sdk.AccAddress(operatorAddr), operatorAddr, del.GetShares())
+	validator, _ := sk.GetValidator(ctx, operatorAddr)
+
+	totalBond := validator.TokensFromShares(del.GetShares()).TruncateInt()
+	msgUnbond := staking.NewMsgUndelegate(sdk.AccAddress(operatorAddr), operatorAddr, sdk.NewCoin(sk.GetParams(ctx).BondDenom, totalBond))
 	res = staking.NewHandler(sk)(ctx, msgUnbond)
 	require.True(t, res.IsOK())
 }
diff --git a/x/slashing/simulation/invariants.go b/x/slashing/simulation/invariants.go
deleted file mode 100644
index 1545db2c7..000000000
--- a/x/slashing/simulation/invariants.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package simulation
-
-import (
-	sdk "github.com/cosmos/cosmos-sdk/types"
-)
-
-// TODO Any invariants to check here?
-// AllInvariants tests all slashing invariants
-func AllInvariants() sdk.Invariant {
-	return func(_ sdk.Context) error {
-		return nil
-	}
-}
diff --git a/x/slashing/simulation/msgs.go b/x/slashing/simulation/msgs.go
index 732b3c28c..9aaa8382d 100644
--- a/x/slashing/simulation/msgs.go
+++ b/x/slashing/simulation/msgs.go
@@ -6,29 +6,27 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
 )
 
 // SimulateMsgUnjail
 func SimulateMsgUnjail(k slashing.Keeper) simulation.Operation {
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		acc := simulation.RandomAcc(r, accs)
 		address := sdk.ValAddress(acc.Address)
 		msg := slashing.NewMsgUnjail(address)
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 		ctx, write := ctx.CacheContext()
-		result := slashing.NewHandler(k)(ctx, msg)
-		if result.IsOK() {
+		ok := slashing.NewHandler(k)(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
-		event(fmt.Sprintf("slashing/MsgUnjail/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgUnjail: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
diff --git a/x/staking/alias.go b/x/staking/alias.go
index 999814b6d..cee0c7b4c 100644
--- a/x/staking/alias.go
+++ b/x/staking/alias.go
@@ -68,6 +68,12 @@ var (
 	UnbondingQueueKey            = keeper.UnbondingQueueKey
 	RedelegationQueueKey         = keeper.RedelegationQueueKey
 	ValidatorQueueKey            = keeper.ValidatorQueueKey
+	RegisterInvariants           = keeper.RegisterInvariants
+	AllInvariants                = keeper.AllInvariants
+	SupplyInvariants             = keeper.SupplyInvariants
+	NonNegativePowerInvariant    = keeper.NonNegativePowerInvariant
+	PositiveDelegationInvariant  = keeper.PositiveDelegationInvariant
+	DelegatorSharesInvariant     = keeper.DelegatorSharesInvariant
 
 	DefaultParamspace = keeper.DefaultParamspace
 	KeyUnbondingTime  = types.KeyUnbondingTime
diff --git a/x/staking/app_test.go b/x/staking/app_test.go
index d4481cef7..da8c52ea5 100644
--- a/x/staking/app_test.go
+++ b/x/staking/app_test.go
@@ -122,22 +122,28 @@ func TestStakingMsgs(t *testing.T) {
 		sdk.ValAddress(addr1), priv1.PubKey(), bondCoin, description, commissionMsg, sdk.OneInt(),
 	)
 
-	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{createValidatorMsg}, []uint64{0}, []uint64{0}, true, true, priv1)
+	header := abci.Header{Height: mApp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, header, []sdk.Msg{createValidatorMsg}, []uint64{0}, []uint64{0}, true, true, priv1)
 	mock.CheckBalance(t, mApp, addr1, sdk.Coins{genCoin.Sub(bondCoin)})
-	mApp.BeginBlock(abci.RequestBeginBlock{})
+
+	header = abci.Header{Height: mApp.LastBlockHeight() + 1}
+	mApp.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 	validator := checkValidator(t, mApp, keeper, sdk.ValAddress(addr1), true)
 	require.Equal(t, sdk.ValAddress(addr1), validator.OperatorAddress)
 	require.Equal(t, sdk.Bonded, validator.Status)
 	require.True(sdk.IntEq(t, bondTokens, validator.BondedTokens()))
 
-	mApp.BeginBlock(abci.RequestBeginBlock{})
+	header = abci.Header{Height: mApp.LastBlockHeight() + 1}
+	mApp.BeginBlock(abci.RequestBeginBlock{Header: header})
 
 	// edit the validator
 	description = NewDescription("bar_moniker", "", "", "")
 	editValidatorMsg := NewMsgEditValidator(sdk.ValAddress(addr1), description, nil, nil)
 
-	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{editValidatorMsg}, []uint64{0}, []uint64{1}, true, true, priv1)
+	header = abci.Header{Height: mApp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, header, []sdk.Msg{editValidatorMsg}, []uint64{0}, []uint64{1}, true, true, priv1)
+
 	validator = checkValidator(t, mApp, keeper, sdk.ValAddress(addr1), true)
 	require.Equal(t, description, validator.Description)
 
@@ -145,13 +151,15 @@ func TestStakingMsgs(t *testing.T) {
 	mock.CheckBalance(t, mApp, addr2, sdk.Coins{genCoin})
 	delegateMsg := NewMsgDelegate(addr2, sdk.ValAddress(addr1), bondCoin)
 
-	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{delegateMsg}, []uint64{0}, []uint64{0}, true, true, priv2)
+	header = abci.Header{Height: mApp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, header, []sdk.Msg{delegateMsg}, []uint64{1}, []uint64{0}, true, true, priv2)
 	mock.CheckBalance(t, mApp, addr2, sdk.Coins{genCoin.Sub(bondCoin)})
 	checkDelegation(t, mApp, keeper, addr2, sdk.ValAddress(addr1), true, bondTokens.ToDec())
 
 	// begin unbonding
-	beginUnbondingMsg := NewMsgUndelegate(addr2, sdk.ValAddress(addr1), bondTokens.ToDec())
-	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{beginUnbondingMsg}, []uint64{0}, []uint64{1}, true, true, priv2)
+	beginUnbondingMsg := NewMsgUndelegate(addr2, sdk.ValAddress(addr1), bondCoin)
+	header = abci.Header{Height: mApp.LastBlockHeight() + 1}
+	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, header, []sdk.Msg{beginUnbondingMsg}, []uint64{1}, []uint64{1}, true, true, priv2)
 
 	// delegation should exist anymore
 	checkDelegation(t, mApp, keeper, addr2, sdk.ValAddress(addr1), false, sdk.Dec{})
diff --git a/x/staking/client/cli/tx.go b/x/staking/client/cli/tx.go
index b5eb8defa..0507fb7ea 100644
--- a/x/staking/client/cli/tx.go
+++ b/x/staking/client/cli/tx.go
@@ -153,7 +153,7 @@ func GetCmdRedelegate(storeName string, cdc *codec.Codec) *cobra.Command {
 		Args:  cobra.ExactArgs(3),
 		Long: strings.TrimSpace(`Redelegate an amount of illiquid staking tokens from one validator to another:
 
-$ gaiacli tx staking redelegate cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm 100 --from mykey
+$ gaiacli tx staking redelegate cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm 100stake --from mykey
 `),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			txBldr := authtxb.NewTxBuilderFromCLI().WithTxEncoder(auth.DefaultTxEncoder(cdc))
@@ -161,8 +161,6 @@ $ gaiacli tx staking redelegate cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmq
 				WithCodec(cdc).
 				WithAccountDecoder(cdc)
 
-			// var err error
-
 			delAddr := cliCtx.GetFromAddress()
 			valSrcAddr, err := sdk.ValAddressFromBech32(args[0])
 			if err != nil {
@@ -174,13 +172,12 @@ $ gaiacli tx staking redelegate cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmq
 				return err
 			}
 
-			// get the shares amount
-			sharesAmount, err := getShares(args[2], delAddr, valSrcAddr)
+			amount, err := sdk.ParseCoin(args[2])
 			if err != nil {
 				return err
 			}
 
-			msg := staking.NewMsgBeginRedelegate(delAddr, valSrcAddr, valDstAddr, sharesAmount)
+			msg := staking.NewMsgBeginRedelegate(delAddr, valSrcAddr, valDstAddr, amount)
 			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}, false)
 		},
 	}
@@ -194,7 +191,7 @@ func GetCmdUnbond(storeName string, cdc *codec.Codec) *cobra.Command {
 		Args:  cobra.ExactArgs(2),
 		Long: strings.TrimSpace(`Unbond an amount of bonded shares from a validator:
 
-$ gaiacli tx staking unbond cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj 100 --from mykey
+$ gaiacli tx staking unbond cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj 100stake --from mykey
 `),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			txBldr := authtxb.NewTxBuilderFromCLI().WithTxEncoder(auth.DefaultTxEncoder(cdc))
@@ -208,13 +205,12 @@ $ gaiacli tx staking unbond cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
 				return err
 			}
 
-			// get the shares amount
-			sharesAmount, err := getShares(args[1], delAddr, valAddr)
+			amount, err := sdk.ParseCoin(args[1])
 			if err != nil {
 				return err
 			}
 
-			msg := staking.NewMsgUndelegate(delAddr, valAddr, sharesAmount)
+			msg := staking.NewMsgUndelegate(delAddr, valAddr, amount)
 			return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}, false)
 		},
 	}
diff --git a/x/staking/client/cli/utils.go b/x/staking/client/cli/utils.go
index 165a761c2..1cd897c27 100644
--- a/x/staking/client/cli/utils.go
+++ b/x/staking/client/cli/utils.go
@@ -7,19 +7,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
-func getShares(sharesAmountStr string, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (sharesAmount sdk.Dec, err error) {
-	sharesAmount, err = sdk.NewDecFromStr(sharesAmountStr)
-	if err != nil {
-		return sharesAmount, err
-	}
-
-	if !sharesAmount.GT(sdk.ZeroDec()) {
-		return sharesAmount, errors.New("shares amount must be positive number (ex. 123, 1.23456789)")
-	}
-
-	return
-}
-
 func buildCommissionMsg(rateStr, maxRateStr, maxChangeRateStr string) (commission types.CommissionMsg, err error) {
 	if rateStr == "" || maxRateStr == "" || maxChangeRateStr == "" {
 		return commission, errors.New("must specify all validator commission parameters")
diff --git a/x/staking/client/rest/query.go b/x/staking/client/rest/query.go
index 8a5a5be3c..63fcc6d24 100644
--- a/x/staking/client/rest/query.go
+++ b/x/staking/client/rest/query.go
@@ -125,14 +125,6 @@ func delegatorTxsHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec) http.Han
 			return
 		}
 
-		node, err := cliCtx.GetNode()
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
-			return
-		}
-
-		// Get values from query
-
 		typesQuery := r.URL.Query().Get("type")
 		trimmedQuery := strings.TrimSpace(typesQuery)
 		if len(trimmedQuery) != 0 {
@@ -167,9 +159,9 @@ func delegatorTxsHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec) http.Han
 		}
 
 		for _, action := range actions {
-			foundTxs, errQuery := queryTxs(node, cliCtx, cdc, action, delegatorAddr)
+			foundTxs, errQuery := queryTxs(cliCtx, cdc, action, delegatorAddr)
 			if errQuery != nil {
-				rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+				rest.WriteErrorResponse(w, http.StatusInternalServerError, errQuery.Error())
 			}
 			txs = append(txs, foundTxs...)
 		}
diff --git a/x/staking/client/rest/tx.go b/x/staking/client/rest/tx.go
index f937dd333..f42a90c9d 100644
--- a/x/staking/client/rest/tx.go
+++ b/x/staking/client/rest/tx.go
@@ -31,35 +31,35 @@ func registerTxRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec
 }
 
 type (
-	// MsgBeginRedelegateInput defines the properties of a delegation request's body.
-	MsgDelegationsInput struct {
+	// DelegateRequest defines the properties of a delegation request's body.
+	DelegateRequest struct {
 		BaseReq          rest.BaseReq   `json:"base_req"`
 		DelegatorAddress sdk.AccAddress `json:"delegator_address"` // in bech32
 		ValidatorAddress sdk.ValAddress `json:"validator_address"` // in bech32
-		Delegation       sdk.Coin       `json:"delegation"`
+		Amount           sdk.Coin       `json:"amount"`
 	}
 
-	// MsgBeginRedelegateInput defines the properties of a redelegate request's body.
-	MsgBeginRedelegateInput struct {
+	// RedelegateRequest defines the properties of a redelegate request's body.
+	RedelegateRequest struct {
 		BaseReq             rest.BaseReq   `json:"base_req"`
 		DelegatorAddress    sdk.AccAddress `json:"delegator_address"`     // in bech32
 		ValidatorSrcAddress sdk.ValAddress `json:"validator_src_address"` // in bech32
 		ValidatorDstAddress sdk.ValAddress `json:"validator_dst_address"` // in bech32
-		SharesAmount        sdk.Dec        `json:"shares"`
+		Amount              sdk.Coin       `json:"amount"`
 	}
 
-	// MsgUndelegateInput defines the properties of a undelegate request's body.
-	MsgUndelegateInput struct {
+	// UndelegateRequest defines the properties of a undelegate request's body.
+	UndelegateRequest struct {
 		BaseReq          rest.BaseReq   `json:"base_req"`
 		DelegatorAddress sdk.AccAddress `json:"delegator_address"` // in bech32
 		ValidatorAddress sdk.ValAddress `json:"validator_address"` // in bech32
-		SharesAmount     sdk.Dec        `json:"shares"`
+		Amount           sdk.Coin       `json:"amount"`
 	}
 )
 
 func postDelegationsHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		var req MsgDelegationsInput
+		var req DelegateRequest
 
 		if !rest.ReadRESTReq(w, r, cdc, &req) {
 			return
@@ -70,7 +70,7 @@ func postDelegationsHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.
 			return
 		}
 
-		msg := staking.NewMsgDelegate(req.DelegatorAddress, req.ValidatorAddress, req.Delegation)
+		msg := staking.NewMsgDelegate(req.DelegatorAddress, req.ValidatorAddress, req.Amount)
 		if err := msg.ValidateBasic(); err != nil {
 			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
 			return
@@ -93,7 +93,7 @@ func postDelegationsHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.
 
 func postRedelegationsHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		var req MsgBeginRedelegateInput
+		var req RedelegateRequest
 
 		if !rest.ReadRESTReq(w, r, cdc, &req) {
 			return
@@ -104,7 +104,7 @@ func postRedelegationsHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx contex
 			return
 		}
 
-		msg := staking.NewMsgBeginRedelegate(req.DelegatorAddress, req.ValidatorSrcAddress, req.ValidatorDstAddress, req.SharesAmount)
+		msg := staking.NewMsgBeginRedelegate(req.DelegatorAddress, req.ValidatorSrcAddress, req.ValidatorDstAddress, req.Amount)
 		if err := msg.ValidateBasic(); err != nil {
 			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
 			return
@@ -127,7 +127,7 @@ func postRedelegationsHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx contex
 
 func postUnbondingDelegationsHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		var req MsgUndelegateInput
+		var req UndelegateRequest
 
 		if !rest.ReadRESTReq(w, r, cdc, &req) {
 			return
@@ -138,7 +138,7 @@ func postUnbondingDelegationsHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx
 			return
 		}
 
-		msg := staking.NewMsgUndelegate(req.DelegatorAddress, req.ValidatorAddress, req.SharesAmount)
+		msg := staking.NewMsgUndelegate(req.DelegatorAddress, req.ValidatorAddress, req.Amount)
 		if err := msg.ValidateBasic(); err != nil {
 			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
 			return
diff --git a/x/staking/client/rest/utils.go b/x/staking/client/rest/utils.go
index dd34dd053..a34864e60 100644
--- a/x/staking/client/rest/utils.go
+++ b/x/staking/client/rest/utils.go
@@ -6,8 +6,6 @@ import (
 
 	"github.com/gorilla/mux"
 
-	rpcclient "github.com/tendermint/tendermint/rpc/client"
-
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/client/tx"
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -28,70 +26,15 @@ func contains(stringSlice []string, txType string) bool {
 }
 
 // queries staking txs
-func queryTxs(node rpcclient.Client, cliCtx context.CLIContext, cdc *codec.Codec, tag string, delegatorAddr string) ([]sdk.TxResponse, error) {
-	page := 0
-	perPage := 100
-	prove := !cliCtx.TrustNode
-	query := fmt.Sprintf("%s='%s' AND %s='%s'", tags.Action, tag, tags.Delegator, delegatorAddr)
-	res, err := node.TxSearch(query, prove, page, perPage)
-	if err != nil {
-		return nil, err
+func queryTxs(cliCtx context.CLIContext, cdc *codec.Codec, tag string, delegatorAddr string) ([]sdk.TxResponse, error) {
+	page := 1
+	limit := 100
+	tags := []string{
+		fmt.Sprintf("%s='%s'", tags.Action, tag),
+		fmt.Sprintf("%s='%s'", tags.Delegator, delegatorAddr),
 	}
 
-	if prove {
-		for _, txData := range res.Txs {
-			err := tx.ValidateTxResult(cliCtx, txData)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	return tx.FormatTxResults(cdc, res.Txs)
-}
-
-func queryRedelegations(cliCtx context.CLIContext, cdc *codec.Codec, endpoint string) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		vars := mux.Vars(r)
-		bech32delegator := vars["delegatorAddr"]
-		bech32srcValidator := vars["srcValidatorAddr"]
-		bech32dstValidator := vars["dstValidatorAddr"]
-
-		delegatorAddr, err := sdk.AccAddressFromBech32(bech32delegator)
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
-			return
-		}
-		srcValidatorAddr, err := sdk.ValAddressFromBech32(bech32srcValidator)
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
-			return
-		}
-		dstValidatorAddr, err := sdk.ValAddressFromBech32(bech32dstValidator)
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
-			return
-		}
-
-		params := staking.QueryRedelegationParams{
-			DelegatorAddr:    delegatorAddr,
-			SrcValidatorAddr: srcValidatorAddr,
-			DstValidatorAddr: dstValidatorAddr,
-		}
-
-		bz, err := cdc.MarshalJSON(params)
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
-			return
-		}
-
-		res, err := cliCtx.QueryWithData(endpoint, bz)
-		if err != nil {
-			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
-			return
-		}
-		rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
-	}
+	return tx.SearchTxs(cliCtx, cdc, tags, page, limit)
 }
 
 func queryBonds(cliCtx context.CLIContext, cdc *codec.Codec, endpoint string) http.HandlerFunc {
diff --git a/x/staking/handler.go b/x/staking/handler.go
index 2897317ee..7da83cec2 100644
--- a/x/staking/handler.go
+++ b/x/staking/handler.go
@@ -209,11 +209,11 @@ func handleMsgDelegate(ctx sdk.Context, msg types.MsgDelegate, k keeper.Keeper)
 		return ErrNoValidatorFound(k.Codespace()).Result()
 	}
 
-	if msg.Value.Denom != k.GetParams(ctx).BondDenom {
+	if msg.Amount.Denom != k.GetParams(ctx).BondDenom {
 		return ErrBadDenom(k.Codespace()).Result()
 	}
 
-	_, err := k.Delegate(ctx, msg.DelegatorAddress, msg.Value.Amount, validator, true)
+	_, err := k.Delegate(ctx, msg.DelegatorAddress, msg.Amount.Amount, validator, true)
 	if err != nil {
 		return err.Result()
 	}
@@ -229,7 +229,14 @@ func handleMsgDelegate(ctx sdk.Context, msg types.MsgDelegate, k keeper.Keeper)
 }
 
 func handleMsgUndelegate(ctx sdk.Context, msg types.MsgUndelegate, k keeper.Keeper) sdk.Result {
-	completionTime, err := k.Undelegate(ctx, msg.DelegatorAddress, msg.ValidatorAddress, msg.SharesAmount)
+	shares, err := k.ValidateUnbondAmount(
+		ctx, msg.DelegatorAddress, msg.ValidatorAddress, msg.Amount.Amount,
+	)
+	if err != nil {
+		return err.Result()
+	}
+
+	completionTime, err := k.Undelegate(ctx, msg.DelegatorAddress, msg.ValidatorAddress, shares)
 	if err != nil {
 		return err.Result()
 	}
@@ -245,8 +252,16 @@ func handleMsgUndelegate(ctx sdk.Context, msg types.MsgUndelegate, k keeper.Keep
 }
 
 func handleMsgBeginRedelegate(ctx sdk.Context, msg types.MsgBeginRedelegate, k keeper.Keeper) sdk.Result {
-	completionTime, err := k.BeginRedelegation(ctx, msg.DelegatorAddress, msg.ValidatorSrcAddress,
-		msg.ValidatorDstAddress, msg.SharesAmount)
+	shares, err := k.ValidateUnbondAmount(
+		ctx, msg.DelegatorAddress, msg.ValidatorSrcAddress, msg.Amount.Amount,
+	)
+	if err != nil {
+		return err.Result()
+	}
+
+	completionTime, err := k.BeginRedelegation(
+		ctx, msg.DelegatorAddress, msg.ValidatorSrcAddress, msg.ValidatorDstAddress, shares,
+	)
 	if err != nil {
 		return err.Result()
 	}
diff --git a/x/staking/handler_test.go b/x/staking/handler_test.go
index 73e895637..19865aeba 100644
--- a/x/staking/handler_test.go
+++ b/x/staking/handler_test.go
@@ -71,6 +71,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	keeper.Slash(ctx, consAddr0, 0, initPower, sdk.NewDecWithPrec(5, 1))
 	keeper.Jail(ctx, consAddr0)
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
+
 	validator, found = keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
 	require.Equal(t, sdk.Unbonding, validator.Status)      // ensure is unbonding
@@ -91,14 +92,18 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	require.Equal(t, power2, power3)
 
 	// unbond self-delegation
-	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, initBond.ToDec())
+	totalBond := validator.TokensFromShares(bond.GetShares()).TruncateInt()
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, totalBond)
+	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, unbondAmt)
+
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
+
 	var finishTime time.Time
 	types.MsgCdc.MustUnmarshalBinaryLengthPrefixed(got.Data, &finishTime)
+
 	ctx = ctx.WithBlockTime(finishTime)
 	EndBlocker(ctx, keeper)
-
 	EndBlocker(ctx, keeper)
 
 	// verify that by power key nolonger exists
@@ -215,8 +220,8 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 	require.Equal(t, bondAmount.MulRaw(2), validator.BondedTokens())
 
 	// unbond validator total self-delegations (which should jail the validator)
-	unbondShares := sdk.TokensFromTendermintPower(10)
-	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, unbondShares.ToDec())
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, bondAmount)
+	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, unbondAmt)
 
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected begin unbonding validator msg to be ok, got %v", got)
@@ -437,8 +442,8 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 
 	// just send the same msgUnbond multiple times
 	// TODO use decimals here
-	unbondShares := sdk.NewDec(10)
-	msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))
+	msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondAmt)
 	numUnbonds := int64(5)
 	for i := int64(0); i < numUnbonds; i++ {
 
@@ -455,8 +460,8 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 		bond, found := keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
 		require.True(t, found)
 
-		expBond := initBond.Sub(unbondShares.MulInt64(i + 1).RoundInt())
-		expDelegatorShares := (initBond.MulRaw(2)).Sub(unbondShares.MulInt64(i + 1).RoundInt())
+		expBond := initBond.Sub(unbondAmt.Amount.Mul(sdk.NewInt(i + 1)))
+		expDelegatorShares := initBond.MulRaw(2).Sub(unbondAmt.Amount.Mul(sdk.NewInt(i + 1)))
 		expDelegatorAcc := initBond.Sub(expBond)
 
 		gotBond := bond.Shares.RoundInt()
@@ -482,28 +487,22 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 		sdk.TokensFromTendermintPower(1 << 31),
 		initBond,
 	}
+
 	for i, c := range errorCases {
-		unbondShares := c.ToDec()
-		msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
+		unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, c)
+		msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondAmt)
 		got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 		require.False(t, got.IsOK(), "expected unbond msg to fail, index: %v", i)
 	}
 
-	leftBonded := initBond.Sub(unbondShares.MulInt64(numUnbonds).RoundInt())
+	leftBonded := initBond.Sub(unbondAmt.Amount.Mul(sdk.NewInt(numUnbonds)))
 
-	// should be unable to unbond one more than we have
-	unbondShares = leftBonded.AddRaw(1).ToDec()
-	msgUndelegate = NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
-	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
-	require.False(t, got.IsOK(),
-		"got: %v\nmsgUnbond: %v\nshares: %v\nleftBonded: %v\n", got, msgUndelegate, unbondShares.String(), leftBonded)
-
-	// should be able to unbond just what we have
-	unbondShares = leftBonded.ToDec()
-	msgUndelegate = NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
+	// should be able to unbond remaining
+	unbondAmt = sdk.NewCoin(sdk.DefaultBondDenom, leftBonded)
+	msgUndelegate = NewMsgUndelegate(delegatorAddr, validatorAddr, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(),
-		"got: %v\nmsgUnbond: %v\nshares: %v\nleftBonded: %v\n", got, msgUndelegate, unbondShares, leftBonded)
+		"got: %v\nmsgUnbond: %v\nshares: %s\nleftBonded: %s\n", got.Log, msgUndelegate, unbondAmt, leftBonded)
 }
 
 func TestMultipleMsgCreateValidator(t *testing.T) {
@@ -548,14 +547,18 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 	for i, validatorAddr := range validatorAddrs {
 		_, found := keeper.GetValidator(ctx, validatorAddr)
 		require.True(t, found)
-		unbondingTokens := sdk.TokensFromTendermintPower(10)
-		msgUndelegate := NewMsgUndelegate(delegatorAddrs[i], validatorAddr, unbondingTokens.ToDec()) // remove delegation
+
+		unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(10))
+		msgUndelegate := NewMsgUndelegate(delegatorAddrs[i], validatorAddr, unbondAmt) // remove delegation
 		got := handleMsgUndelegate(ctx, msgUndelegate, keeper)
+
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
 		var finishTime time.Time
+
 		// Jump to finishTime for unbonding period and remove from unbonding queue
 		types.MsgCdc.MustUnmarshalBinaryLengthPrefixed(got.Data, &finishTime)
 		ctx = ctx.WithBlockTime(finishTime)
+
 		EndBlocker(ctx, keeper)
 
 		// Check that the validator is deleted from state
@@ -576,7 +579,7 @@ func TestMultipleMsgDelegate(t *testing.T) {
 	validatorAddr, delegatorAddrs := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1:]
 	_ = setInstantUnbondPeriod(keeper, ctx)
 
-	//first make a validator
+	// first make a validator
 	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
@@ -587,7 +590,7 @@ func TestMultipleMsgDelegate(t *testing.T) {
 		got := handleMsgDelegate(ctx, msgDelegate, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
 
-		//Check that the account is bonded
+		// check that the account is bonded
 		bond, found := keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
 		require.True(t, found)
 		require.NotNil(t, bond, "expected delegatee bond %d to exist", bond)
@@ -595,15 +598,19 @@ func TestMultipleMsgDelegate(t *testing.T) {
 
 	// unbond them all
 	for i, delegatorAddr := range delegatorAddrs {
-		msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, sdk.NewDec(10))
+		unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))
+		msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondAmt)
+
 		got := handleMsgUndelegate(ctx, msgUndelegate, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
+
 		var finishTime time.Time
 		types.MsgCdc.MustUnmarshalBinaryLengthPrefixed(got.Data, &finishTime)
+
 		ctx = ctx.WithBlockTime(finishTime)
 		EndBlocker(ctx, keeper)
 
-		//Check that the account is unbonded
+		// check that the account is unbonded
 		_, found := keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
 		require.False(t, found)
 	}
@@ -625,11 +632,14 @@ func TestJailValidator(t *testing.T) {
 	require.True(t, got.IsOK(), "expected ok, got %v", got)
 
 	// unbond the validators bond portion
-	msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))
+	msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error: %v", got)
+
 	var finishTime time.Time
 	types.MsgCdc.MustUnmarshalBinaryLengthPrefixed(got.Data, &finishTime)
+
 	ctx = ctx.WithBlockTime(finishTime)
 	EndBlocker(ctx, keeper)
 
@@ -638,10 +648,12 @@ func TestJailValidator(t *testing.T) {
 	require.True(t, validator.Jailed, "%v", validator)
 
 	// test that the delegator can still withdraw their bonds
-	msgUndelegateDelegator := NewMsgUndelegate(delegatorAddr, validatorAddr, sdk.NewDec(10))
+	msgUndelegateDelegator := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondAmt)
+
 	got = handleMsgUndelegate(ctx, msgUndelegateDelegator, keeper)
 	require.True(t, got.IsOK(), "expected no error")
 	types.MsgCdc.MustUnmarshalBinaryLengthPrefixed(got.Data, &finishTime)
+
 	ctx = ctx.WithBlockTime(finishTime)
 	EndBlocker(ctx, keeper)
 
@@ -674,14 +686,17 @@ func TestValidatorQueue(t *testing.T) {
 	EndBlocker(ctx, keeper)
 
 	// unbond the all self-delegation to put validator in unbonding state
-	msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr),
-		validatorAddr, delTokens.ToDec())
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, delTokens)
+	msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error: %v", got)
+
 	var finishTime time.Time
 	types.MsgCdc.MustUnmarshalBinaryLengthPrefixed(got.Data, &finishTime)
+
 	ctx = ctx.WithBlockTime(finishTime)
 	EndBlocker(ctx, keeper)
+
 	origHeader := ctx.BlockHeader()
 
 	validator, found := keeper.GetValidator(ctx, validatorAddr)
@@ -691,6 +706,7 @@ func TestValidatorQueue(t *testing.T) {
 	// should still be unbonding at time 6 seconds later
 	ctx = ctx.WithBlockTime(origHeader.Time.Add(time.Second * 6))
 	EndBlocker(ctx, keeper)
+
 	validator, found = keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
 	require.True(t, validator.GetStatus() == sdk.Unbonding, "%v", validator)
@@ -698,6 +714,7 @@ func TestValidatorQueue(t *testing.T) {
 	// should be in unbonded state at time 7 seconds later
 	ctx = ctx.WithBlockTime(origHeader.Time.Add(time.Second * 7))
 	EndBlocker(ctx, keeper)
+
 	validator, found = keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
 	require.True(t, validator.GetStatus() == sdk.Unbonded, "%v", validator)
@@ -721,11 +738,11 @@ func TestUnbondingPeriod(t *testing.T) {
 	EndBlocker(ctx, keeper)
 
 	// begin unbonding
-	unbondingTokens := sdk.TokensFromTendermintPower(10)
-	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr),
-		validatorAddr, unbondingTokens.ToDec())
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(10))
+	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error")
+
 	origHeader := ctx.BlockHeader()
 
 	_, found := keeper.GetUnbondingDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
@@ -764,7 +781,8 @@ func TestUnbondingFromUnbondingValidator(t *testing.T) {
 	require.True(t, got.IsOK(), "expected ok, got %v", got)
 
 	// unbond the validators bond portion
-	msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))
+	msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error")
 
@@ -774,7 +792,7 @@ func TestUnbondingFromUnbondingValidator(t *testing.T) {
 	ctx = ctx.WithBlockTime(finishTime.Add(time.Second * -1))
 
 	// unbond the delegator from the validator
-	msgUndelegateDelegator := NewMsgUndelegate(delegatorAddr, validatorAddr, sdk.NewDec(10))
+	msgUndelegateDelegator := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegateDelegator, keeper)
 	require.True(t, got.IsOK(), "expected no error")
 
@@ -820,7 +838,8 @@ func TestRedelegationPeriod(t *testing.T) {
 	bal1 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins()
 
 	// begin redelegate
-	msgBeginRedelegate := NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2, sdk.NewDec(10))
+	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))
+	msgBeginRedelegate := NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2, redAmt)
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -873,12 +892,13 @@ func TestTransitiveRedelegation(t *testing.T) {
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	// begin redelegate
-	msgBeginRedelegate := NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2, sdk.NewDec(10))
+	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))
+	msgBeginRedelegate := NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2, redAmt)
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
 	// cannot redelegation to next validator while first delegation exists
-	msgBeginRedelegate = NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr2, validatorAddr3, sdk.NewDec(10))
+	msgBeginRedelegate = NewMsgBeginRedelegate(sdk.AccAddress(validatorAddr), validatorAddr2, validatorAddr3, redAmt)
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, !got.IsOK(), "expected an error, msg: %v", msgBeginRedelegate)
 
@@ -915,8 +935,8 @@ func TestMultipleRedelegationAtSameTime(t *testing.T) {
 
 	// begin a redelegate
 	selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
-	msgBeginRedelegate := NewMsgBeginRedelegate(selfDelAddr,
-		valAddr, valAddr2, valTokens.QuoRaw(2).ToDec())
+	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, valTokens.QuoRaw(2))
+	msgBeginRedelegate := NewMsgBeginRedelegate(selfDelAddr, valAddr, valAddr2, redAmt)
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -967,8 +987,8 @@ func TestMultipleRedelegationAtUniqueTimes(t *testing.T) {
 
 	// begin a redelegate
 	selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
-	msgBeginRedelegate := NewMsgBeginRedelegate(selfDelAddr,
-		valAddr, valAddr2, valTokens.QuoRaw(2).ToDec())
+	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, valTokens.QuoRaw(2))
+	msgBeginRedelegate := NewMsgBeginRedelegate(selfDelAddr, valAddr, valAddr2, redAmt)
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -1016,7 +1036,8 @@ func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) {
 
 	// begin an unbonding delegation
 	selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
-	msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, valTokens.QuoRaw(2).ToDec())
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, valTokens.QuoRaw(2))
+	msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -1062,7 +1083,8 @@ func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) {
 
 	// begin an unbonding delegation
 	selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
-	msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, valTokens.QuoRaw(2).ToDec())
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, valTokens.QuoRaw(2))
+	msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -1132,8 +1154,9 @@ func TestUnbondingWhenExcessValidators(t *testing.T) {
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 	require.Equal(t, 2, len(keeper.GetLastValidators(ctx)))
 
-	// unbond the valdator-2
-	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr2), validatorAddr2, valTokens2.ToDec())
+	// unbond the validator-2
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, valTokens2)
+	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr2), validatorAddr2, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgUndelegate")
 
@@ -1177,21 +1200,21 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	ctx = ctx.WithBlockHeight(1)
 
 	// begin unbonding 4 stake
-	ubdTokens := sdk.TokensFromTendermintPower(4)
-	msgUndelegate := NewMsgUndelegate(del, valA, ubdTokens.ToDec())
+	unbondAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(4))
+	msgUndelegate := NewMsgUndelegate(del, valA, unbondAmt)
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgUndelegate")
 
 	// begin redelegate 6 stake
-	rdTokens := sdk.TokensFromTendermintPower(6)
-	msgBeginRedelegate := NewMsgBeginRedelegate(del, valA, valB, rdTokens.ToDec())
+	redAmt := sdk.NewCoin(sdk.DefaultBondDenom, sdk.TokensFromTendermintPower(6))
+	msgBeginRedelegate := NewMsgBeginRedelegate(del, valA, valB, redAmt)
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgBeginRedelegate")
 
 	// destination delegation should have 6 shares
 	delegation, found := keeper.GetDelegation(ctx, del, valB)
 	require.True(t, found)
-	require.Equal(t, rdTokens.ToDec(), delegation.Shares)
+	require.Equal(t, sdk.NewDecFromInt(redAmt.Amount), delegation.Shares)
 
 	// must apply validator updates
 	updates = keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@@ -1204,7 +1227,7 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	ubd, found := keeper.GetUnbondingDelegation(ctx, del, valA)
 	require.True(t, found)
 	require.Len(t, ubd.Entries, 1)
-	require.Equal(t, ubdTokens.QuoRaw(2), ubd.Entries[0].Balance)
+	require.Equal(t, unbondAmt.Amount.QuoRaw(2), ubd.Entries[0].Balance)
 
 	// redelegation should have been slashed by half
 	redelegation, found := keeper.GetRedelegation(ctx, del, valA, valB)
@@ -1214,7 +1237,7 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	// destination delegation should have been slashed by half
 	delegation, found = keeper.GetDelegation(ctx, del, valB)
 	require.True(t, found)
-	require.Equal(t, rdTokens.QuoRaw(2).ToDec(), delegation.Shares)
+	require.Equal(t, sdk.NewDecFromInt(redAmt.Amount.QuoRaw(2)), delegation.Shares)
 
 	// validator power should have been reduced by half
 	validator, found := keeper.GetValidator(ctx, valA)
@@ -1229,7 +1252,7 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	ubd, found = keeper.GetUnbondingDelegation(ctx, del, valA)
 	require.True(t, found)
 	require.Len(t, ubd.Entries, 1)
-	require.Equal(t, ubdTokens.QuoRaw(2), ubd.Entries[0].Balance)
+	require.Equal(t, unbondAmt.Amount.QuoRaw(2), ubd.Entries[0].Balance)
 
 	// redelegation should be unchanged
 	redelegation, found = keeper.GetRedelegation(ctx, del, valA, valB)
@@ -1239,7 +1262,7 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	// destination delegation should be unchanged
 	delegation, found = keeper.GetDelegation(ctx, del, valB)
 	require.True(t, found)
-	require.Equal(t, rdTokens.QuoRaw(2).ToDec(), delegation.Shares)
+	require.Equal(t, sdk.NewDecFromInt(redAmt.Amount.QuoRaw(2)), delegation.Shares)
 
 	// end blocker
 	EndBlocker(ctx, keeper)
diff --git a/x/staking/keeper/delegation.go b/x/staking/keeper/delegation.go
index 86adf577c..f13c2b40f 100644
--- a/x/staking/keeper/delegation.go
+++ b/x/staking/keeper/delegation.go
@@ -518,7 +518,7 @@ func (k Keeper) unbond(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValA
 	// if the delegation is the operator of the validator and undelegating will decrease the validator's self delegation below their minimum
 	// trigger a jail validator
 	if isValidatorOperator && !validator.Jailed &&
-		validator.ShareTokens(delegation.Shares).TruncateInt().LT(validator.MinSelfDelegation) {
+		validator.TokensFromShares(delegation.Shares).TruncateInt().LT(validator.MinSelfDelegation) {
 
 		k.jailValidator(ctx, validator)
 		validator = k.mustGetValidator(ctx, validator.OperatorAddress)
@@ -726,3 +726,46 @@ func (k Keeper) CompleteRedelegation(ctx sdk.Context, delAddr sdk.AccAddress,
 
 	return nil
 }
+
+// ValidateUnbondAmount validates that a given unbond or redelegation amount is
+// valied based on upon the converted shares. If the amount is valid, the total
+// amount of respective shares is returned, otherwise an error is returned.
+func (k Keeper) ValidateUnbondAmount(
+	ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt sdk.Int,
+) (shares sdk.Dec, err sdk.Error) {
+
+	validator, found := k.GetValidator(ctx, valAddr)
+	if !found {
+		return shares, types.ErrNoValidatorFound(k.Codespace())
+	}
+
+	del, found := k.GetDelegation(ctx, delAddr, valAddr)
+	if !found {
+		return shares, types.ErrNoDelegation(k.Codespace())
+	}
+
+	shares, err = validator.SharesFromTokens(amt)
+	if err != nil {
+		return shares, err
+	}
+
+	sharesTruncated, err := validator.SharesFromTokensTruncated(amt)
+	if err != nil {
+		return shares, err
+	}
+
+	delShares := del.GetShares()
+	if sharesTruncated.GT(delShares) {
+		return shares, types.ErrBadSharesAmount(k.Codespace())
+	}
+
+	// Cap the shares at the delegation's shares. Shares being greater could occur
+	// due to rounding, however we don't want to truncate the shares or take the
+	// minimum because we want to allow for the full withdraw of shares from a
+	// delegation.
+	if shares.GT(delShares) {
+		shares = delShares
+	}
+
+	return shares, nil
+}
diff --git a/x/staking/simulation/invariants.go b/x/staking/keeper/invariants.go
similarity index 79%
rename from x/staking/simulation/invariants.go
rename to x/staking/keeper/invariants.go
index db6249719..f9a495a4f 100644
--- a/x/staking/simulation/invariants.go
+++ b/x/staking/keeper/invariants.go
@@ -1,4 +1,4 @@
-package simulation
+package keeper
 
 import (
 	"bytes"
@@ -6,15 +6,26 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
-	"github.com/cosmos/cosmos-sdk/x/staking"
-	"github.com/cosmos/cosmos-sdk/x/staking/keeper"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
+// register all staking invariants
+func RegisterInvariants(c types.CrisisKeeper, k Keeper, f types.FeeCollectionKeeper,
+	d types.DistributionKeeper, am auth.AccountKeeper) {
+
+	c.RegisterRoute(types.ModuleName, "supply",
+		SupplyInvariants(k, f, d, am))
+	c.RegisterRoute(types.ModuleName, "nonnegative-power",
+		NonNegativePowerInvariant(k))
+	c.RegisterRoute(types.ModuleName, "positive-delegation",
+		PositiveDelegationInvariant(k))
+	c.RegisterRoute(types.ModuleName, "delegator-shares",
+		DelegatorSharesInvariant(k))
+}
+
 // AllInvariants runs all invariants of the staking module.
-// Currently: total supply, positive power
-func AllInvariants(k staking.Keeper,
-	f staking.FeeCollectionKeeper, d staking.DistributionKeeper,
-	am auth.AccountKeeper) sdk.Invariant {
+func AllInvariants(k Keeper, f types.FeeCollectionKeeper,
+	d types.DistributionKeeper, am auth.AccountKeeper) sdk.Invariant {
 
 	return func(ctx sdk.Context) error {
 		err := SupplyInvariants(k, f, d, am)(ctx)
@@ -43,8 +54,9 @@ func AllInvariants(k staking.Keeper,
 
 // SupplyInvariants checks that the total supply reflects all held not-bonded tokens, bonded tokens, and unbonding delegations
 // nolint: unparam
-func SupplyInvariants(k staking.Keeper,
-	f staking.FeeCollectionKeeper, d staking.DistributionKeeper, am auth.AccountKeeper) sdk.Invariant {
+func SupplyInvariants(k Keeper, f types.FeeCollectionKeeper,
+	d types.DistributionKeeper, am auth.AccountKeeper) sdk.Invariant {
+
 	return func(ctx sdk.Context) error {
 		pool := k.GetPool(ctx)
 
@@ -54,7 +66,7 @@ func SupplyInvariants(k staking.Keeper,
 			loose = loose.Add(acc.GetCoins().AmountOf(k.BondDenom(ctx)).ToDec())
 			return false
 		})
-		k.IterateUnbondingDelegations(ctx, func(_ int64, ubd staking.UnbondingDelegation) bool {
+		k.IterateUnbondingDelegations(ctx, func(_ int64, ubd types.UnbondingDelegation) bool {
 			for _, entry := range ubd.Entries {
 				loose = loose.Add(entry.Balance.ToDec())
 			}
@@ -98,7 +110,7 @@ func SupplyInvariants(k staking.Keeper,
 }
 
 // NonNegativePowerInvariant checks that all stored validators have >= 0 power.
-func NonNegativePowerInvariant(k staking.Keeper) sdk.Invariant {
+func NonNegativePowerInvariant(k Keeper) sdk.Invariant {
 	return func(ctx sdk.Context) error {
 		iterator := k.ValidatorsPowerStoreIterator(ctx)
 
@@ -108,7 +120,7 @@ func NonNegativePowerInvariant(k staking.Keeper) sdk.Invariant {
 				panic(fmt.Sprintf("validator record not found for address: %X\n", iterator.Value()))
 			}
 
-			powerKey := keeper.GetValidatorsByPowerIndexKey(validator)
+			powerKey := GetValidatorsByPowerIndexKey(validator)
 
 			if !bytes.Equal(iterator.Key(), powerKey) {
 				return fmt.Errorf("power store invariance:\n\tvalidator.Power: %v"+
@@ -126,7 +138,7 @@ func NonNegativePowerInvariant(k staking.Keeper) sdk.Invariant {
 }
 
 // PositiveDelegationInvariant checks that all stored delegations have > 0 shares.
-func PositiveDelegationInvariant(k staking.Keeper) sdk.Invariant {
+func PositiveDelegationInvariant(k Keeper) sdk.Invariant {
 	return func(ctx sdk.Context) error {
 		delegations := k.GetAllDelegations(ctx)
 		for _, delegation := range delegations {
@@ -145,7 +157,7 @@ func PositiveDelegationInvariant(k staking.Keeper) sdk.Invariant {
 // DelegatorSharesInvariant checks whether all the delegator shares which persist
 // in the delegator object add up to the correct total delegator shares
 // amount stored in each validator
-func DelegatorSharesInvariant(k staking.Keeper) sdk.Invariant {
+func DelegatorSharesInvariant(k Keeper) sdk.Invariant {
 	return func(ctx sdk.Context) error {
 		validators := k.GetAllValidators(ctx)
 		for _, validator := range validators {
diff --git a/x/staking/keeper/slash_test.go b/x/staking/keeper/slash_test.go
index 99f68a332..283fc9f67 100644
--- a/x/staking/keeper/slash_test.go
+++ b/x/staking/keeper/slash_test.go
@@ -51,19 +51,19 @@ func TestRevocation(t *testing.T) {
 	// initial state
 	val, found := keeper.GetValidator(ctx, addr)
 	require.True(t, found)
-	require.False(t, val.GetJailed())
+	require.False(t, val.IsJailed())
 
 	// test jail
 	keeper.Jail(ctx, consAddr)
 	val, found = keeper.GetValidator(ctx, addr)
 	require.True(t, found)
-	require.True(t, val.GetJailed())
+	require.True(t, val.IsJailed())
 
 	// test unjail
 	keeper.Unjail(ctx, consAddr)
 	val, found = keeper.GetValidator(ctx, addr)
 	require.True(t, found)
-	require.False(t, val.GetJailed())
+	require.False(t, val.IsJailed())
 }
 
 // tests slashUnbondingDelegation
diff --git a/x/staking/simulation/msgs.go b/x/staking/simulation/msgs.go
index 559b0ae96..c7268afb2 100644
--- a/x/staking/simulation/msgs.go
+++ b/x/staking/simulation/msgs.go
@@ -7,21 +7,17 @@ import (
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
-	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
 	"github.com/cosmos/cosmos-sdk/x/staking"
 	"github.com/cosmos/cosmos-sdk/x/staking/keeper"
 )
 
-const (
-	noOperation = "no-operation"
-)
-
 // SimulateMsgCreateValidator
 func SimulateMsgCreateValidator(m auth.AccountKeeper, k staking.Keeper) simulation.Operation {
 	handler := staking.NewHandler(k)
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (
+		opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		denom := k.GetParams(ctx).BondDenom
 		description := staking.Description{
@@ -43,7 +39,7 @@ func SimulateMsgCreateValidator(m auth.AccountKeeper, k staking.Keeper) simulati
 		}
 
 		if amount.Equal(sdk.ZeroInt()) {
-			return noOperation, nil, nil
+			return simulation.NoOpMsg(), nil, nil
 		}
 
 		selfDelegation := sdk.NewCoin(denom, amount)
@@ -51,20 +47,17 @@ func SimulateMsgCreateValidator(m auth.AccountKeeper, k staking.Keeper) simulati
 			selfDelegation, description, commission, sdk.OneInt())
 
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 
 		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
+		ok := handler(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
 
-		event(fmt.Sprintf("staking/MsgCreateValidator/%v", result.IsOK()))
-
-		// require.True(t, result.IsOK(), "expected OK result but instead got %v", result)
-		action = fmt.Sprintf("TestMsgCreateValidator: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
@@ -72,8 +65,7 @@ func SimulateMsgCreateValidator(m auth.AccountKeeper, k staking.Keeper) simulati
 func SimulateMsgEditValidator(k staking.Keeper) simulation.Operation {
 	handler := staking.NewHandler(k)
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		description := staking.Description{
 			Moniker:  simulation.RandStringOfLength(r, 10),
@@ -83,7 +75,7 @@ func SimulateMsgEditValidator(k staking.Keeper) simulation.Operation {
 		}
 
 		if len(k.GetAllValidators(ctx)) == 0 {
-			return noOperation, nil, nil
+			return simulation.NoOpMsg(), nil, nil
 		}
 		val := keeper.RandomValidator(r, k, ctx)
 		address := val.GetOperator()
@@ -92,16 +84,15 @@ func SimulateMsgEditValidator(k staking.Keeper) simulation.Operation {
 		msg := staking.NewMsgEditValidator(address, description, &newCommissionRate, nil)
 
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
+		ok := handler(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
-		event(fmt.Sprintf("staking/MsgEditValidator/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgEditValidator: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
@@ -109,12 +100,11 @@ func SimulateMsgEditValidator(k staking.Keeper) simulation.Operation {
 func SimulateMsgDelegate(m auth.AccountKeeper, k staking.Keeper) simulation.Operation {
 	handler := staking.NewHandler(k)
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		denom := k.GetParams(ctx).BondDenom
 		if len(k.GetAllValidators(ctx)) == 0 {
-			return noOperation, nil, nil
+			return simulation.NoOpMsg(), nil, nil
 		}
 		val := keeper.RandomValidator(r, k, ctx)
 		validatorAddress := val.GetOperator()
@@ -125,23 +115,22 @@ func SimulateMsgDelegate(m auth.AccountKeeper, k staking.Keeper) simulation.Oper
 			amount = simulation.RandomAmount(r, amount)
 		}
 		if amount.Equal(sdk.ZeroInt()) {
-			return noOperation, nil, nil
+			return simulation.NoOpMsg(), nil, nil
 		}
 
 		msg := staking.NewMsgDelegate(
 			delegatorAddress, validatorAddress, sdk.NewCoin(denom, amount))
 
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
 		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
+		ok := handler(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
-		event(fmt.Sprintf("staking/MsgDelegate/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgDelegate: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
@@ -149,38 +138,43 @@ func SimulateMsgDelegate(m auth.AccountKeeper, k staking.Keeper) simulation.Oper
 func SimulateMsgUndelegate(m auth.AccountKeeper, k staking.Keeper) simulation.Operation {
 	handler := staking.NewHandler(k)
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		delegatorAcc := simulation.RandomAcc(r, accs)
 		delegatorAddress := delegatorAcc.Address
 		delegations := k.GetAllDelegatorDelegations(ctx, delegatorAddress)
 		if len(delegations) == 0 {
-			return noOperation, nil, nil
+			return simulation.NoOpMsg(), nil, nil
 		}
 		delegation := delegations[r.Intn(len(delegations))]
 
-		numShares := simulation.RandomDecAmount(r, delegation.Shares)
-		if numShares.Equal(sdk.ZeroDec()) {
-			return noOperation, nil, nil
+		validator, found := k.GetValidator(ctx, delegation.GetValidatorAddr())
+		if !found {
+			return simulation.NoOpMsg(), nil, nil
 		}
-		msg := staking.MsgUndelegate{
-			DelegatorAddress: delegatorAddress,
-			ValidatorAddress: delegation.ValidatorAddress,
-			SharesAmount:     numShares,
+
+		totalBond := validator.TokensFromShares(delegation.GetShares()).TruncateInt()
+		unbondAmt := simulation.RandomAmount(r, totalBond)
+		if unbondAmt.Equal(sdk.ZeroInt()) {
+			return simulation.NoOpMsg(), nil, nil
 		}
+
+		msg := staking.NewMsgDelegate(
+			delegatorAddress, delegation.ValidatorAddress, sdk.NewCoin(k.GetParams(ctx).BondDenom, unbondAmt),
+		)
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s, got error %v",
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s, got error %v",
 				msg.GetSignBytes(), msg.ValidateBasic())
 		}
+
 		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
+		ok := handler(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
-		event(fmt.Sprintf("staking/MsgUndelegate/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgUndelegate: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
 
@@ -188,12 +182,11 @@ func SimulateMsgUndelegate(m auth.AccountKeeper, k staking.Keeper) simulation.Op
 func SimulateMsgBeginRedelegate(m auth.AccountKeeper, k staking.Keeper) simulation.Operation {
 	handler := staking.NewHandler(k)
 	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context,
-		accs []simulation.Account, event func(string)) (
-		action string, fOp []simulation.FutureOperation, err error) {
+		accs []simulation.Account) (opMsg simulation.OperationMsg, fOps []simulation.FutureOperation, err error) {
 
 		denom := k.GetParams(ctx).BondDenom
 		if len(k.GetAllValidators(ctx)) == 0 {
-			return noOperation, nil, nil
+			return simulation.NoOpMsg(), nil, nil
 		}
 		srcVal := keeper.RandomValidator(r, k, ctx)
 		srcValidatorAddress := srcVal.GetOperator()
@@ -207,24 +200,23 @@ func SimulateMsgBeginRedelegate(m auth.AccountKeeper, k staking.Keeper) simulati
 			amount = simulation.RandomAmount(r, amount)
 		}
 		if amount.Equal(sdk.ZeroInt()) {
-			return noOperation, nil, nil
-		}
-		msg := staking.MsgBeginRedelegate{
-			DelegatorAddress:    delegatorAddress,
-			ValidatorSrcAddress: srcValidatorAddress,
-			ValidatorDstAddress: destValidatorAddress,
-			SharesAmount:        amount.ToDec(),
+			return simulation.NoOpMsg(), nil, nil
 		}
+
+		msg := staking.NewMsgBeginRedelegate(
+			delegatorAddress, srcValidatorAddress, destValidatorAddress, sdk.NewCoin(denom, amount),
+		)
 		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
+			return simulation.NoOpMsg(), nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
 		}
+
 		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
+		ok := handler(ctx, msg).IsOK()
+		if ok {
 			write()
 		}
-		event(fmt.Sprintf("staking/MsgBeginRedelegate/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgBeginRedelegate: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
+
+		opMsg = simulation.NewOperationMsg(msg, ok, "")
+		return opMsg, nil, nil
 	}
 }
diff --git a/x/staking/types/commission.go b/x/staking/types/commission.go
index 89c356039..e30d20dd5 100644
--- a/x/staking/types/commission.go
+++ b/x/staking/types/commission.go
@@ -119,8 +119,7 @@ func (c Commission) ValidateNewRate(newRate sdk.Dec, blockTime time.Time) sdk.Er
 		// new rate cannot be greater than the max rate
 		return ErrCommissionGTMaxRate(DefaultCodespace)
 
-		// TODO: why do we need an absolute value, do we care if the validator decreases their rate rapidly?
-	case newRate.Sub(c.Rate).Abs().GT(c.MaxChangeRate):
+	case newRate.Sub(c.Rate).GT(c.MaxChangeRate):
 		// new rate % points change cannot be greater than the max change rate
 		return ErrCommissionGTMaxChangeRate(DefaultCodespace)
 	}
diff --git a/x/staking/types/commission_test.go b/x/staking/types/commission_test.go
new file mode 100644
index 000000000..ec6186122
--- /dev/null
+++ b/x/staking/types/commission_test.go
@@ -0,0 +1,72 @@
+package types
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func TestCommissionValidate(t *testing.T) {
+	testCases := []struct {
+		input     Commission
+		expectErr bool
+	}{
+		// invalid commission; max rate < 0%
+		{NewCommission(sdk.ZeroDec(), sdk.MustNewDecFromStr("-1.00"), sdk.ZeroDec()), true},
+		// invalid commission; max rate > 100%
+		{NewCommission(sdk.ZeroDec(), sdk.MustNewDecFromStr("2.00"), sdk.ZeroDec()), true},
+		// invalid commission; rate < 0%
+		{NewCommission(sdk.MustNewDecFromStr("-1.00"), sdk.ZeroDec(), sdk.ZeroDec()), true},
+		// invalid commission; rate > max rate
+		{NewCommission(sdk.MustNewDecFromStr("0.75"), sdk.MustNewDecFromStr("0.50"), sdk.ZeroDec()), true},
+		// invalid commission; max change rate < 0%
+		{NewCommission(sdk.OneDec(), sdk.OneDec(), sdk.MustNewDecFromStr("-1.00")), true},
+		// invalid commission; max change rate > max rate
+		{NewCommission(sdk.OneDec(), sdk.MustNewDecFromStr("0.75"), sdk.MustNewDecFromStr("0.90")), true},
+		// valid commission
+		{NewCommission(sdk.MustNewDecFromStr("0.20"), sdk.OneDec(), sdk.MustNewDecFromStr("0.10")), false},
+	}
+
+	for i, tc := range testCases {
+		err := tc.input.Validate()
+		require.Equal(t, tc.expectErr, err != nil, "unexpected result; tc #%d, input: %v", i, tc.input)
+	}
+}
+
+func TestCommissionValidateNewRate(t *testing.T) {
+	now := time.Now().UTC()
+	c1 := NewCommission(sdk.MustNewDecFromStr("0.40"), sdk.MustNewDecFromStr("0.80"), sdk.MustNewDecFromStr("0.10"))
+	c1.UpdateTime = now
+
+	testCases := []struct {
+		input     Commission
+		newRate   sdk.Dec
+		blockTime time.Time
+		expectErr bool
+	}{
+		// invalid new commission rate; last update < 24h ago
+		{c1, sdk.MustNewDecFromStr("0.50"), now, true},
+		// invalid new commission rate; new rate < 0%
+		{c1, sdk.MustNewDecFromStr("-1.00"), now.Add(48 * time.Hour), true},
+		// invalid new commission rate; new rate > max rate
+		{c1, sdk.MustNewDecFromStr("0.90"), now.Add(48 * time.Hour), true},
+		// invalid new commission rate; new rate > max change rate
+		{c1, sdk.MustNewDecFromStr("0.60"), now.Add(48 * time.Hour), true},
+		// valid commission
+		{c1, sdk.MustNewDecFromStr("0.50"), now.Add(48 * time.Hour), false},
+		// valid commission
+		{c1, sdk.MustNewDecFromStr("0.10"), now.Add(48 * time.Hour), false},
+	}
+
+	for i, tc := range testCases {
+		err := tc.input.ValidateNewRate(tc.newRate, tc.blockTime)
+		require.Equal(
+			t, tc.expectErr, err != nil,
+			"unexpected result; tc #%d, input: %v, newRate: %s, blockTime: %s",
+			i, tc.input, tc.newRate, tc.blockTime,
+		)
+	}
+}
diff --git a/x/staking/types/expected_keepers.go b/x/staking/types/expected_keepers.go
index 54c9bad62..2a2aff060 100644
--- a/x/staking/types/expected_keepers.go
+++ b/x/staking/types/expected_keepers.go
@@ -18,3 +18,8 @@ type BankKeeper interface {
 	DelegateCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Tags, sdk.Error)
 	UndelegateCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Tags, sdk.Error)
 }
+
+// expected crisis keeper
+type CrisisKeeper interface {
+	RegisterRoute(moduleName, route string, invar sdk.Invariant)
+}
diff --git a/x/staking/types/msg.go b/x/staking/types/msg.go
index f9c2eea77..9bf839fa2 100644
--- a/x/staking/types/msg.go
+++ b/x/staking/types/msg.go
@@ -212,14 +212,14 @@ func (msg MsgEditValidator) ValidateBasic() sdk.Error {
 type MsgDelegate struct {
 	DelegatorAddress sdk.AccAddress `json:"delegator_address"`
 	ValidatorAddress sdk.ValAddress `json:"validator_address"`
-	Value            sdk.Coin       `json:"value"`
+	Amount           sdk.Coin       `json:"amount"`
 }
 
-func NewMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, value sdk.Coin) MsgDelegate {
+func NewMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount sdk.Coin) MsgDelegate {
 	return MsgDelegate{
 		DelegatorAddress: delAddr,
 		ValidatorAddress: valAddr,
-		Value:            value,
+		Amount:           amount,
 	}
 }
 
@@ -244,7 +244,7 @@ func (msg MsgDelegate) ValidateBasic() sdk.Error {
 	if msg.ValidatorAddress.Empty() {
 		return ErrNilValidatorAddr(DefaultCodespace)
 	}
-	if msg.Value.Amount.LTE(sdk.ZeroInt()) {
+	if msg.Amount.Amount.LTE(sdk.ZeroInt()) {
 		return ErrBadDelegationAmount(DefaultCodespace)
 	}
 	return nil
@@ -257,17 +257,17 @@ type MsgBeginRedelegate struct {
 	DelegatorAddress    sdk.AccAddress `json:"delegator_address"`
 	ValidatorSrcAddress sdk.ValAddress `json:"validator_src_address"`
 	ValidatorDstAddress sdk.ValAddress `json:"validator_dst_address"`
-	SharesAmount        sdk.Dec        `json:"shares_amount"`
+	Amount              sdk.Coin       `json:"amount"`
 }
 
 func NewMsgBeginRedelegate(delAddr sdk.AccAddress, valSrcAddr,
-	valDstAddr sdk.ValAddress, sharesAmount sdk.Dec) MsgBeginRedelegate {
+	valDstAddr sdk.ValAddress, amount sdk.Coin) MsgBeginRedelegate {
 
 	return MsgBeginRedelegate{
 		DelegatorAddress:    delAddr,
 		ValidatorSrcAddress: valSrcAddr,
 		ValidatorDstAddress: valDstAddr,
-		SharesAmount:        sharesAmount,
+		Amount:              amount,
 	}
 }
 
@@ -295,7 +295,7 @@ func (msg MsgBeginRedelegate) ValidateBasic() sdk.Error {
 	if msg.ValidatorDstAddress.Empty() {
 		return ErrNilValidatorAddr(DefaultCodespace)
 	}
-	if msg.SharesAmount.LTE(sdk.ZeroDec()) {
+	if msg.Amount.Amount.LTE(sdk.ZeroInt()) {
 		return ErrBadSharesAmount(DefaultCodespace)
 	}
 	return nil
@@ -305,14 +305,14 @@ func (msg MsgBeginRedelegate) ValidateBasic() sdk.Error {
 type MsgUndelegate struct {
 	DelegatorAddress sdk.AccAddress `json:"delegator_address"`
 	ValidatorAddress sdk.ValAddress `json:"validator_address"`
-	SharesAmount     sdk.Dec        `json:"shares_amount"`
+	Amount           sdk.Coin       `json:"amount"`
 }
 
-func NewMsgUndelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount sdk.Dec) MsgUndelegate {
+func NewMsgUndelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount sdk.Coin) MsgUndelegate {
 	return MsgUndelegate{
 		DelegatorAddress: delAddr,
 		ValidatorAddress: valAddr,
-		SharesAmount:     sharesAmount,
+		Amount:           amount,
 	}
 }
 
@@ -335,7 +335,7 @@ func (msg MsgUndelegate) ValidateBasic() sdk.Error {
 	if msg.ValidatorAddress.Empty() {
 		return ErrNilValidatorAddr(DefaultCodespace)
 	}
-	if msg.SharesAmount.LTE(sdk.ZeroDec()) {
+	if msg.Amount.Amount.LTE(sdk.ZeroInt()) {
 		return ErrBadSharesAmount(DefaultCodespace)
 	}
 	return nil
diff --git a/x/staking/types/msg_test.go b/x/staking/types/msg_test.go
index a2a60a44e..da0cdae00 100644
--- a/x/staking/types/msg_test.go
+++ b/x/staking/types/msg_test.go
@@ -110,19 +110,18 @@ func TestMsgBeginRedelegate(t *testing.T) {
 		delegatorAddr    sdk.AccAddress
 		validatorSrcAddr sdk.ValAddress
 		validatorDstAddr sdk.ValAddress
-		sharesAmount     sdk.Dec
+		amount           sdk.Coin
 		expectPass       bool
 	}{
-		{"regular", sdk.AccAddress(addr1), addr2, addr3, sdk.NewDecWithPrec(1, 1), true},
-		{"negative decimal", sdk.AccAddress(addr1), addr2, addr3, sdk.NewDecWithPrec(-1, 1), false},
-		{"zero amount", sdk.AccAddress(addr1), addr2, addr3, sdk.ZeroDec(), false},
-		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, addr3, sdk.NewDecWithPrec(1, 1), false},
-		{"empty source validator", sdk.AccAddress(addr1), emptyAddr, addr3, sdk.NewDecWithPrec(1, 1), false},
-		{"empty destination validator", sdk.AccAddress(addr1), addr2, emptyAddr, sdk.NewDecWithPrec(1, 1), false},
+		{"regular", sdk.AccAddress(addr1), addr2, addr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), true},
+		{"zero amount", sdk.AccAddress(addr1), addr2, addr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 0), false},
+		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, addr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
+		{"empty source validator", sdk.AccAddress(addr1), emptyAddr, addr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
+		{"empty destination validator", sdk.AccAddress(addr1), addr2, emptyAddr, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
 	}
 
 	for _, tc := range tests {
-		msg := NewMsgBeginRedelegate(tc.delegatorAddr, tc.validatorSrcAddr, tc.validatorDstAddr, tc.sharesAmount)
+		msg := NewMsgBeginRedelegate(tc.delegatorAddr, tc.validatorSrcAddr, tc.validatorDstAddr, tc.amount)
 		if tc.expectPass {
 			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
 		} else {
@@ -137,18 +136,17 @@ func TestMsgUndelegate(t *testing.T) {
 		name          string
 		delegatorAddr sdk.AccAddress
 		validatorAddr sdk.ValAddress
-		sharesAmount  sdk.Dec
+		amount        sdk.Coin
 		expectPass    bool
 	}{
-		{"regular", sdk.AccAddress(addr1), addr2, sdk.NewDecWithPrec(1, 1), true},
-		{"negative decimal", sdk.AccAddress(addr1), addr2, sdk.NewDecWithPrec(-1, 1), false},
-		{"zero amount", sdk.AccAddress(addr1), addr2, sdk.ZeroDec(), false},
-		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, sdk.NewDecWithPrec(1, 1), false},
-		{"empty validator", sdk.AccAddress(addr1), emptyAddr, sdk.NewDecWithPrec(1, 1), false},
+		{"regular", sdk.AccAddress(addr1), addr2, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), true},
+		{"zero amount", sdk.AccAddress(addr1), addr2, sdk.NewInt64Coin(sdk.DefaultBondDenom, 0), false},
+		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
+		{"empty validator", sdk.AccAddress(addr1), emptyAddr, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
 	}
 
 	for _, tc := range tests {
-		msg := NewMsgUndelegate(tc.delegatorAddr, tc.validatorAddr, tc.sharesAmount)
+		msg := NewMsgUndelegate(tc.delegatorAddr, tc.validatorAddr, tc.amount)
 		if tc.expectPass {
 			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
 		} else {
diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go
index 730d43073..c048de744 100644
--- a/x/staking/types/validator.go
+++ b/x/staking/types/validator.go
@@ -354,7 +354,12 @@ func (v Validator) AddTokensFromDel(pool Pool, amount sdk.Int) (Validator, Pool,
 		// the first delegation to a validator sets the exchange rate to one
 		issuedShares = amount.ToDec()
 	} else {
-		issuedShares = v.DelegatorShares.MulInt(amount).QuoInt(v.Tokens)
+		shares, err := v.SharesFromTokens(amount)
+		if err != nil {
+			panic(err)
+		}
+
+		issuedShares = shares
 	}
 
 	if v.Status == sdk.Bonded {
@@ -384,7 +389,7 @@ func (v Validator) RemoveDelShares(pool Pool, delShares sdk.Dec) (Validator, Poo
 
 		// leave excess tokens in the validator
 		// however fully use all the delegator shares
-		issuedTokens = v.ShareTokens(delShares).TruncateInt()
+		issuedTokens = v.TokensFromShares(delShares).TruncateInt()
 		v.Tokens = v.Tokens.Sub(issuedTokens)
 		if v.Tokens.IsNegative() {
 			panic("attempting to remove more tokens than available in validator")
@@ -407,15 +412,41 @@ func (v Validator) InvalidExRate() bool {
 }
 
 // calculate the token worth of provided shares
-func (v Validator) ShareTokens(shares sdk.Dec) sdk.Dec {
+func (v Validator) TokensFromShares(shares sdk.Dec) sdk.Dec {
 	return (shares.MulInt(v.Tokens)).Quo(v.DelegatorShares)
 }
 
 // calculate the token worth of provided shares, truncated
-func (v Validator) ShareTokensTruncated(shares sdk.Dec) sdk.Dec {
+func (v Validator) TokensFromSharesTruncated(shares sdk.Dec) sdk.Dec {
 	return (shares.MulInt(v.Tokens)).QuoTruncate(v.DelegatorShares)
 }
 
+// TokensFromSharesRoundUp returns the token worth of provided shares, rounded
+// up.
+func (v Validator) TokensFromSharesRoundUp(shares sdk.Dec) sdk.Dec {
+	return (shares.MulInt(v.Tokens)).QuoRoundUp(v.DelegatorShares)
+}
+
+// SharesFromTokens returns the shares of a delegation given a bond amount. It
+// returns an error if the validator has no tokens.
+func (v Validator) SharesFromTokens(amt sdk.Int) (sdk.Dec, sdk.Error) {
+	if v.Tokens.IsZero() {
+		return sdk.ZeroDec(), ErrInsufficientShares(DefaultCodespace)
+	}
+
+	return v.GetDelegatorShares().MulInt(amt).QuoInt(v.GetTokens()), nil
+}
+
+// SharesFromTokensTruncated returns the truncated shares of a delegation given
+// a bond amount. It returns an error if the validator has no tokens.
+func (v Validator) SharesFromTokensTruncated(amt sdk.Int) (sdk.Dec, sdk.Error) {
+	if v.Tokens.IsZero() {
+		return sdk.ZeroDec(), ErrInsufficientShares(DefaultCodespace)
+	}
+
+	return v.GetDelegatorShares().MulInt(amt).QuoTruncate(v.GetTokens().ToDec()), nil
+}
+
 // get the bonded tokens which the validator holds
 func (v Validator) BondedTokens() sdk.Int {
 	if v.Status == sdk.Bonded {
@@ -442,7 +473,7 @@ func (v Validator) PotentialTendermintPower() int64 {
 var _ sdk.Validator = Validator{}
 
 // nolint - for sdk.Validator
-func (v Validator) GetJailed() bool               { return v.Jailed }
+func (v Validator) IsJailed() bool                { return v.Jailed }
 func (v Validator) GetMoniker() string            { return v.Description.Moniker }
 func (v Validator) GetStatus() sdk.BondStatus     { return v.Status }
 func (v Validator) GetOperator() sdk.ValAddress   { return v.OperatorAddress }
diff --git a/x/staking/types/validator_test.go b/x/staking/types/validator_test.go
index b8b1fb5c7..bd90427e7 100644
--- a/x/staking/types/validator_test.go
+++ b/x/staking/types/validator_test.go
@@ -77,11 +77,11 @@ func TestShareTokens(t *testing.T) {
 		Tokens:          sdk.NewInt(100),
 		DelegatorShares: sdk.NewDec(100),
 	}
-	assert.True(sdk.DecEq(t, sdk.NewDec(50), validator.ShareTokens(sdk.NewDec(50))))
+	assert.True(sdk.DecEq(t, sdk.NewDec(50), validator.TokensFromShares(sdk.NewDec(50))))
 
 	validator.Tokens = sdk.NewInt(50)
-	assert.True(sdk.DecEq(t, sdk.NewDec(25), validator.ShareTokens(sdk.NewDec(50))))
-	assert.True(sdk.DecEq(t, sdk.NewDec(5), validator.ShareTokens(sdk.NewDec(10))))
+	assert.True(sdk.DecEq(t, sdk.NewDec(25), validator.TokensFromShares(sdk.NewDec(50))))
+	assert.True(sdk.DecEq(t, sdk.NewDec(5), validator.TokensFromShares(sdk.NewDec(10))))
 }
 
 func TestRemoveTokens(t *testing.T) {