diff --git a/docs/core/proto-docs.md b/docs/core/proto-docs.md
index cd09e43a3..c478e0926 100644
--- a/docs/core/proto-docs.md
+++ b/docs/core/proto-docs.md
@@ -13654,7 +13654,6 @@ Wasm code to the system
 | ----- | ---- | ----- | ----------- |
 | `sender` | [string](#string) |  | Sender is the that actor that signed the messages |
 | `wasm_byte_code` | [bytes](#bytes) |  | WASMByteCode can be raw or gzip compressed |
-| `code_id` | [uint64](#uint64) |  | CodeID is optional |
 
 
 
diff --git a/proto/terra/wasm/v1beta1/tx.proto b/proto/terra/wasm/v1beta1/tx.proto
index b4962742c..d76814d75 100644
--- a/proto/terra/wasm/v1beta1/tx.proto
+++ b/proto/terra/wasm/v1beta1/tx.proto
@@ -34,8 +34,6 @@ message MsgStoreCode {
   string sender = 1 [(gogoproto.moretags) = "yaml:\"sender\""];
   // WASMByteCode can be raw or gzip compressed
   bytes wasm_byte_code = 2 [(gogoproto.moretags) = "yaml:\"wasm_byte_code\"", (gogoproto.customname) = "WASMByteCode"];
-  // CodeID is optional
-  uint64 code_id = 3 [(gogoproto.moretags) = "yaml:\"code_id\"", (gogoproto.customname) = "CodeID"];
 }
 
 // MsgStoreCodeResponse defines the Msg/StoreCode response type.
diff --git a/x/market/keeper/keeper_test.go b/x/market/keeper/keeper_test.go
index afc7a4164..b8cb1dcf1 100644
--- a/x/market/keeper/keeper_test.go
+++ b/x/market/keeper/keeper_test.go
@@ -67,6 +67,6 @@ func TestReplenishPools(t *testing.T) {
 
 	burnPoolDelta = input.MarketKeeper.GetBurnPoolDelta(input.Ctx)
 	burnReplenishAmt := burnDiff.QuoInt64(recoveryPeriod)
-	expectedBurnDelta := mintDiff.Sub(burnReplenishAmt)
+	expectedBurnDelta := burnDiff.Sub(burnReplenishAmt)
 	require.Equal(t, expectedBurnDelta, burnPoolDelta)
 }
diff --git a/x/market/keeper/params.go b/x/market/keeper/params.go
index a70ac6722..ab2bbffea 100644
--- a/x/market/keeper/params.go
+++ b/x/market/keeper/params.go
@@ -14,7 +14,7 @@ func (k Keeper) MintBasePool(ctx sdk.Context) (res sdk.Dec) {
 
 // BurnBasePool is burn liquidity pool(usdr unit) which will be made available per PoolRecoveryPeriod
 func (k Keeper) BurnBasePool(ctx sdk.Context) (res sdk.Dec) {
-	k.paramSpace.Get(ctx, types.KeyMintBasePool, &res)
+	k.paramSpace.Get(ctx, types.KeyBurnBasePool, &res)
 	return
 }
 
diff --git a/x/oracle/abci.go b/x/oracle/abci.go
index 709c68538..c973ccbe6 100644
--- a/x/oracle/abci.go
+++ b/x/oracle/abci.go
@@ -16,89 +16,95 @@ func EndBlocker(ctx sdk.Context, k keeper.Keeper) {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyEndBlocker)
 
 	params := k.GetParams(ctx)
+	if core.IsPeriodLastBlock(ctx, params.VotePeriod) {
 
-	// Not yet time for a tally
-	if !core.IsPeriodLastBlock(ctx, params.VotePeriod) {
-		return
-	}
-
-	// Build claim map over all validators in active set
-	validatorClaimMap := make(map[string]types.Claim)
+		// Build claim map over all validators in active set
+		validatorClaimMap := make(map[string]types.Claim)
 
-	maxValidators := k.StakingKeeper.MaxValidators(ctx)
-	iterator := k.StakingKeeper.ValidatorsPowerStoreIterator(ctx)
-	defer iterator.Close()
+		maxValidators := k.StakingKeeper.MaxValidators(ctx)
+		iterator := k.StakingKeeper.ValidatorsPowerStoreIterator(ctx)
+		defer iterator.Close()
 
-	powerReduction := k.StakingKeeper.PowerReduction(ctx)
+		powerReduction := k.StakingKeeper.PowerReduction(ctx)
 
-	i := 0
-	for ; iterator.Valid() && i < int(maxValidators); iterator.Next() {
-		validator := k.StakingKeeper.Validator(ctx, iterator.Value())
+		i := 0
+		for ; iterator.Valid() && i < int(maxValidators); iterator.Next() {
+			validator := k.StakingKeeper.Validator(ctx, iterator.Value())
 
-		// Exclude not bonded validator
-		if validator.IsBonded() {
-			valAddr := validator.GetOperator()
-			validatorClaimMap[valAddr.String()] = types.NewClaim(validator.GetConsensusPower(powerReduction), 0, 0, valAddr)
-			i++
+			// Exclude not bonded validator
+			if validator.IsBonded() {
+				valAddr := validator.GetOperator()
+				validatorClaimMap[valAddr.String()] = types.NewClaim(validator.GetConsensusPower(powerReduction), 0, 0, valAddr)
+				i++
+			}
 		}
-	}
 
-	// Denom-TobinTax map
-	voteTargets := make(map[string]sdk.Dec)
-	k.IterateTobinTaxes(ctx, func(denom string, tobinTax sdk.Dec) bool {
-		voteTargets[denom] = tobinTax
-		return false
-	})
-
-	// Clear all exchange rates
-	k.IterateLunaExchangeRates(ctx, func(denom string, _ sdk.Dec) (stop bool) {
-		k.DeleteLunaExchangeRate(ctx, denom)
-		return false
-	})
-
-	// Organize votes to ballot by denom
-	// NOTE: **Filter out inactive or jailed validators**
-	// NOTE: **Make abstain votes to have zero vote power**
-	voteMap := k.OrganizeBallotByDenom(ctx, validatorClaimMap)
-
-	if referenceTerra := pickReferenceTerra(ctx, k, voteTargets, voteMap); referenceTerra != "" {
-		// make voteMap of Reference Terra to calculate cross exchange rates
-		ballotRT := voteMap[referenceTerra]
-		voteMapRT := ballotRT.ToMap()
-		exchangeRateRT := ballotRT.WeightedMedian()
-
-		// Iterate through ballots and update exchange rates; drop if not enough votes have been achieved.
-		for denom, ballot := range voteMap {
-
-			// Convert ballot to cross exchange rates
-			if denom != referenceTerra {
-				ballot = ballot.ToCrossRate(voteMapRT)
+		// Denom-TobinTax map
+		voteTargets := make(map[string]sdk.Dec)
+		k.IterateTobinTaxes(ctx, func(denom string, tobinTax sdk.Dec) bool {
+			voteTargets[denom] = tobinTax
+			return false
+		})
+
+		// Clear all exchange rates
+		k.IterateLunaExchangeRates(ctx, func(denom string, _ sdk.Dec) (stop bool) {
+			k.DeleteLunaExchangeRate(ctx, denom)
+			return false
+		})
+
+		// Organize votes to ballot by denom
+		// NOTE: **Filter out inactive or jailed validators**
+		// NOTE: **Make abstain votes to have zero vote power**
+		voteMap := k.OrganizeBallotByDenom(ctx, validatorClaimMap)
+
+		if referenceTerra := pickReferenceTerra(ctx, k, voteTargets, voteMap); referenceTerra != "" {
+			// make voteMap of Reference Terra to calculate cross exchange rates
+			ballotRT := voteMap[referenceTerra]
+			voteMapRT := ballotRT.ToMap()
+			exchangeRateRT := ballotRT.WeightedMedian()
+
+			// Iterate through ballots and update exchange rates; drop if not enough votes have been achieved.
+			for denom, ballot := range voteMap {
+
+				// Convert ballot to cross exchange rates
+				if denom != referenceTerra {
+					ballot = ballot.ToCrossRate(voteMapRT)
+				}
+
+				// Get weighted median of cross exchange rates
+				exchangeRate := Tally(ctx, ballot, params.RewardBand, validatorClaimMap)
+
+				// Transform into the original form uluna/stablecoin
+				if denom != referenceTerra {
+					exchangeRate = exchangeRateRT.Quo(exchangeRate)
+				}
+
+				// Set the exchange rate, emit ABCI event
+				k.SetLunaExchangeRateWithEvent(ctx, denom, exchangeRate)
 			}
+		}
 
-			// Get weighted median of cross exchange rates
-			exchangeRate := Tally(ctx, ballot, params.RewardBand, validatorClaimMap)
-
-			// Transform into the original form uluna/stablecoin
-			if denom != referenceTerra {
-				exchangeRate = exchangeRateRT.Quo(exchangeRate)
+		//---------------------------
+		// Do miss counting & slashing
+		voteTargetsLen := len(voteTargets)
+		for _, claim := range validatorClaimMap {
+			// Skip abstain & valid voters
+			if int(claim.WinCount) == voteTargetsLen {
+				continue
 			}
 
-			// Set the exchange rate, emit ABCI event
-			k.SetLunaExchangeRateWithEvent(ctx, denom, exchangeRate)
+			// Increase miss counter
+			k.SetMissCounter(ctx, claim.Recipient, k.GetMissCounter(ctx, claim.Recipient)+1)
 		}
-	}
 
-	//---------------------------
-	// Do miss counting & slashing
-	voteTargetsLen := len(voteTargets)
-	for _, claim := range validatorClaimMap {
-		// Skip abstain & valid voters
-		if int(claim.WinCount) == voteTargetsLen {
-			continue
-		}
+		// Distribute rewards to ballot winners
+		k.RewardBallotWinners(ctx, validatorClaimMap)
+
+		// Clear the ballot
+		k.ClearBallots(ctx, params.VotePeriod)
 
-		// Increase miss counter
-		k.SetMissCounter(ctx, claim.Recipient, k.GetMissCounter(ctx, claim.Recipient)+1)
+		// Update vote targets and tobin tax
+		k.ApplyWhitelist(ctx, params.Whitelist, voteTargets)
 	}
 
 	// Do slash who did miss voting over threshold and
@@ -107,14 +113,5 @@ func EndBlocker(ctx sdk.Context, k keeper.Keeper) {
 		k.SlashAndResetMissCounters(ctx)
 	}
 
-	// Distribute rewards to ballot winners
-	k.RewardBallotWinners(ctx, validatorClaimMap)
-
-	// Clear the ballot
-	k.ClearBallots(ctx, params.VotePeriod)
-
-	// Update vote targets and tobin tax
-	k.ApplyWhitelist(ctx, params.Whitelist, voteTargets)
-
 	return
 }
diff --git a/x/oracle/abci_test.go b/x/oracle/abci_test.go
index f52bc826a..78b4fa056 100644
--- a/x/oracle/abci_test.go
+++ b/x/oracle/abci_test.go
@@ -3,6 +3,7 @@ package oracle_test
 import (
 	"fmt"
 	"math"
+	"sort"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -167,6 +168,7 @@ func TestOracleTally(t *testing.T) {
 			Recipient: valAddr,
 		}
 	}
+	sort.Sort(ballot)
 	weightedMedian := ballot.WeightedMedian()
 	standardDeviation := ballot.StandardDeviation()
 	maxSpread := weightedMedian.Mul(input.OracleKeeper.RewardBand(input.Ctx).QuoInt64(2))
diff --git a/x/oracle/client/rest/tx.go b/x/oracle/client/rest/tx.go
index a8a116cca..66c010ce2 100644
--- a/x/oracle/client/rest/tx.go
+++ b/x/oracle/client/rest/tx.go
@@ -59,13 +59,6 @@ func newDelegateHandlerFunction(clientCtx client.Context) http.HandlerFunc {
 			return
 		}
 
-		// Bytes comparison, so do not require type conversion
-		if !voterAddr.Equals(req.Feeder) {
-			err := fmt.Errorf("[%v] can not change [%v] delegation", req.Feeder, voterAddr)
-			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
-			return
-		}
-
 		// create the message
 		msg := types.NewMsgDelegateFeedConsent(voterAddr, req.Feeder)
 		if rest.CheckBadRequestError(w, msg.ValidateBasic()) {
@@ -109,12 +102,15 @@ func newAggregatePrevoteHandlerFunction(clientCtx client.Context) http.HandlerFu
 			}
 
 			hash = types.GetAggregateVoteHash(req.Salt, req.ExchangeRates, voterAddr)
-		} else {
+		} else if len(req.Hash) > 0 {
 			hash, err = types.AggregateVoteHashFromHexString(req.Hash)
 			if err != nil {
 				rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
 				return
 			}
+		} else {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, "must provide Hash or (ExchangeRates & Salt)")
+			return
 		}
 
 		// create the message
diff --git a/x/oracle/keeper/ballot.go b/x/oracle/keeper/ballot.go
index 34f32f41d..d0e3b600a 100644
--- a/x/oracle/keeper/ballot.go
+++ b/x/oracle/keeper/ballot.go
@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/terra-money/core/x/oracle/types"
@@ -44,6 +45,13 @@ func (k Keeper) OrganizeBallotByDenom(ctx sdk.Context, validatorClaimMap map[str
 	}
 
 	k.IterateAggregateExchangeRateVotes(ctx, aggregateHandler)
+
+	// sort created ballot
+	for denom, ballot := range votes {
+		sort.Sort(ballot)
+		votes[denom] = ballot
+	}
+
 	return
 }
 
diff --git a/x/oracle/keeper/keeper.go b/x/oracle/keeper/keeper.go
index 93ae5e98f..90611e525 100644
--- a/x/oracle/keeper/keeper.go
+++ b/x/oracle/keeper/keeper.go
@@ -358,7 +358,7 @@ func (k Keeper) ValidateFeeder(ctx sdk.Context, feederAddr sdk.AccAddress, valid
 	}
 
 	// Check that the given validator exists
-	if val := k.StakingKeeper.Validator(ctx, validatorAddr); !val.IsBonded() {
+	if val := k.StakingKeeper.Validator(ctx, validatorAddr); val == nil || !val.IsBonded() {
 		return sdkerrors.Wrapf(stakingtypes.ErrNoValidatorFound, "validator %s is not active set", validatorAddr.String())
 	}
 
diff --git a/x/oracle/keeper/msg_server.go b/x/oracle/keeper/msg_server.go
index e72a85ee3..caba44d03 100644
--- a/x/oracle/keeper/msg_server.go
+++ b/x/oracle/keeper/msg_server.go
@@ -33,11 +33,8 @@ func (ms msgServer) AggregateExchangeRatePrevote(goCtx context.Context, msg *typ
 		return nil, err
 	}
 
-	if !feederAddr.Equals(valAddr) {
-		delegate := ms.GetFeederDelegation(ctx, valAddr)
-		if !delegate.Equals(feederAddr) {
-			return nil, sdkerrors.Wrap(types.ErrNoVotingPermission, msg.Feeder)
-		}
+	if err := ms.ValidateFeeder(ctx, feederAddr, valAddr); err != nil {
+		return nil, err
 	}
 
 	// Convert hex string to votehash
@@ -46,12 +43,6 @@ func (ms msgServer) AggregateExchangeRatePrevote(goCtx context.Context, msg *typ
 		return nil, sdkerrors.Wrap(types.ErrInvalidHash, err.Error())
 	}
 
-	// Check that the given validator exists
-	val := ms.StakingKeeper.Validator(ctx, valAddr)
-	if val == nil {
-		return nil, sdkerrors.Wrap(stakingtypes.ErrNoValidatorFound, msg.Validator)
-	}
-
 	aggregatePrevote := types.NewAggregateExchangeRatePrevote(voteHash, valAddr, uint64(ctx.BlockHeight()))
 	ms.SetAggregateExchangeRatePrevote(ctx, valAddr, aggregatePrevote)
 
@@ -83,17 +74,8 @@ func (ms msgServer) AggregateExchangeRateVote(goCtx context.Context, msg *types.
 		return nil, err
 	}
 
-	if !feederAddr.Equals(valAddr) {
-		delegate := ms.GetFeederDelegation(ctx, valAddr)
-		if !delegate.Equals(feederAddr) {
-			return nil, sdkerrors.Wrap(types.ErrNoVotingPermission, msg.Feeder)
-		}
-	}
-
-	// Check that the given validator exists
-	val := ms.StakingKeeper.Validator(ctx, valAddr)
-	if val == nil {
-		return nil, sdkerrors.Wrap(stakingtypes.ErrNoValidatorFound, msg.Validator)
+	if err := ms.ValidateFeeder(ctx, feederAddr, valAddr); err != nil {
+		return nil, err
 	}
 
 	params := ms.GetParams(ctx)
diff --git a/x/oracle/simulation/operations.go b/x/oracle/simulation/operations.go
index 43683b955..d36e3c08a 100644
--- a/x/oracle/simulation/operations.go
+++ b/x/oracle/simulation/operations.go
@@ -91,7 +91,7 @@ func SimulateMsgAggregateExchangeRatePrevote(ak types.AccountKeeper, bk types.Ba
 
 		// ensure the validator exists
 		val := k.StakingKeeper.Validator(ctx, address)
-		if val == nil {
+		if val == nil || !val.IsBonded() {
 			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgAggregateExchangeRatePrevote, "unable to find validator"), nil, nil
 		}
 
@@ -155,7 +155,7 @@ func SimulateMsgAggregateExchangeRateVote(ak types.AccountKeeper, bk types.BankK
 
 		// ensure the validator exists
 		val := k.StakingKeeper.Validator(ctx, address)
-		if val == nil {
+		if val == nil || !val.IsBonded() {
 			return simtypes.NoOpMsg(types.ModuleName, types.TypeMsgAggregateExchangeRateVote, "unable to find validator"), nil, nil
 		}
 
diff --git a/x/oracle/tally.go b/x/oracle/tally.go
index 925c4bac4..88c41a4e2 100644
--- a/x/oracle/tally.go
+++ b/x/oracle/tally.go
@@ -42,10 +42,7 @@ func Tally(ctx sdk.Context, pb types.ExchangeRateBallot, rewardBand sdk.Dec, val
 }
 
 // ballot for the asset is passing the threshold amount of voting power
-func ballotIsPassing(ctx sdk.Context, ballot types.ExchangeRateBallot, k keeper.Keeper) (sdk.Int, bool) {
-	totalBondedPower := sdk.TokensToConsensusPower(k.StakingKeeper.TotalBondedTokens(ctx), k.StakingKeeper.PowerReduction(ctx))
-	voteThreshold := k.VoteThreshold(ctx)
-	thresholdVotes := voteThreshold.MulInt64(totalBondedPower).RoundInt()
+func ballotIsPassing(ballot types.ExchangeRateBallot, thresholdVotes sdk.Int) (sdk.Int, bool) {
 	ballotPower := sdk.NewInt(ballot.Power())
 	return ballotPower, !ballotPower.IsZero() && ballotPower.GTE(thresholdVotes)
 }
@@ -57,6 +54,10 @@ func pickReferenceTerra(ctx sdk.Context, k keeper.Keeper, voteTargets map[string
 	largestBallotPower := int64(0)
 	referenceTerra := ""
 
+	totalBondedPower := sdk.TokensToConsensusPower(k.StakingKeeper.TotalBondedTokens(ctx), k.StakingKeeper.PowerReduction(ctx))
+	voteThreshold := k.VoteThreshold(ctx)
+	thresholdVotes := voteThreshold.MulInt64(totalBondedPower).RoundInt()
+
 	for denom, ballot := range voteMap {
 		// If denom is not in the voteTargets, or the ballot for it has failed, then skip
 		// and remove it from voteMap for iteration efficiency
@@ -69,7 +70,7 @@ func pickReferenceTerra(ctx sdk.Context, k keeper.Keeper, voteTargets map[string
 
 		// If the ballot is not passed, remove it from the voteTargets array
 		// to prevent slashing validators who did valid vote.
-		if power, ok := ballotIsPassing(ctx, ballot, k); ok {
+		if power, ok := ballotIsPassing(ballot, thresholdVotes); ok {
 			ballotPower = power.Int64()
 		} else {
 			delete(voteTargets, denom)
diff --git a/x/oracle/types/ballot.go b/x/oracle/types/ballot.go
index 62ec4e2bd..12aff8271 100644
--- a/x/oracle/types/ballot.go
+++ b/x/oracle/types/ballot.go
@@ -79,7 +79,7 @@ func (pb ExchangeRateBallot) WeightedMedian() sdk.Dec {
 	totalPower := pb.Power()
 	if pb.Len() > 0 {
 		if !sort.IsSorted(pb) {
-			sort.Sort(pb)
+			panic("ballot must be sorted")
 		}
 
 		pivot := int64(0)
@@ -126,7 +126,7 @@ func (pb ExchangeRateBallot) Len() int {
 // Less reports whether the element with
 // index i should sort before the element with index j.
 func (pb ExchangeRateBallot) Less(i, j int) bool {
-	return pb[i].ExchangeRate.LTE(pb[j].ExchangeRate)
+	return pb[i].ExchangeRate.LT(pb[j].ExchangeRate)
 }
 
 // Swap implements sort.Interface.
diff --git a/x/oracle/types/ballot_test.go b/x/oracle/types/ballot_test.go
index 646926311..1f2c74a04 100644
--- a/x/oracle/types/ballot_test.go
+++ b/x/oracle/types/ballot_test.go
@@ -167,7 +167,7 @@ func TestPBWeightedMedian(t *testing.T) {
 	}{
 		{
 			// Supermajority one number
-			[]int64{2, 1, 10, 100000},
+			[]int64{1, 2, 10, 100000},
 			[]int64{1, 1, 100, 1},
 			[]bool{true, true, true, true},
 			sdk.NewDec(10),
diff --git a/x/oracle/types/params.go b/x/oracle/types/params.go
index 8823c968c..b7b848602 100644
--- a/x/oracle/types/params.go
+++ b/x/oracle/types/params.go
@@ -100,7 +100,7 @@ func (p Params) Validate() error {
 	}
 
 	if p.RewardDistributionWindow < p.VotePeriod {
-		return fmt.Errorf("oracle parameter RewardDistributionWindow must be greater than or equal with votes period")
+		return fmt.Errorf("oracle parameter RewardDistributionWindow must be greater than or equal with VotePeriod")
 	}
 
 	if p.SlashFraction.GT(sdk.OneDec()) || p.SlashFraction.IsNegative() {
@@ -108,7 +108,7 @@ func (p Params) Validate() error {
 	}
 
 	if p.SlashWindow < p.VotePeriod {
-		return fmt.Errorf("oracle parameter SlashWindow must be greater than or equal with votes period")
+		return fmt.Errorf("oracle parameter SlashWindow must be greater than or equal with VotePeriod")
 	}
 
 	if p.MinValidPerWindow.GT(sdk.OneDec()) || p.MinValidPerWindow.IsNegative() {
diff --git a/x/treasury/legacy/v05/migrate.go b/x/treasury/legacy/v05/migrate.go
index 5b9a528e2..1e28c1ca0 100644
--- a/x/treasury/legacy/v05/migrate.go
+++ b/x/treasury/legacy/v05/migrate.go
@@ -30,7 +30,7 @@ func Migrate(
 
 	// Remove cumulative height dependencies
 	cumulativeEpochs := int(treasuryGenState.CumulativeHeight / int64(v04treasury.BlocksPerWeek))
-	epochStates := make([]v05treasury.EpochState, len(treasuryGenState.TRs))
+	epochStates := make([]v05treasury.EpochState, len(treasuryGenState.TRs)-cumulativeEpochs)
 	for i := range treasuryGenState.TRs {
 		if i < cumulativeEpochs {
 			continue
diff --git a/x/vesting/types/schedule.go b/x/vesting/types/schedule.go
index 77c8f1ffc..76383fb25 100644
--- a/x/vesting/types/schedule.go
+++ b/x/vesting/types/schedule.go
@@ -100,7 +100,6 @@ func (vs VestingSchedule) GetDenom() string {
 func (vs VestingSchedule) Validate() error {
 	sumRatio := sdk.ZeroDec()
 	for _, lazySchedule := range vs.Schedules {
-
 		if err := lazySchedule.Validate(); err != nil {
 			return err
 		}
diff --git a/x/vesting/types/vesting_account.go b/x/vesting/types/vesting_account.go
index 7f860dbb7..18ed8331b 100644
--- a/x/vesting/types/vesting_account.go
+++ b/x/vesting/types/vesting_account.go
@@ -1,6 +1,7 @@
 package types
 
 import (
+	fmt "fmt"
 	"time"
 
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
@@ -125,10 +126,17 @@ func (lgva LazyGradedVestingAccount) GetEndTime() int64 {
 
 // Validate checks for errors on the account fields
 func (lgva LazyGradedVestingAccount) Validate() error {
+	denomMap := make(map[string]bool)
 	for _, vestingSchedule := range lgva.GetVestingSchedules() {
+		if _, ok := denomMap[vestingSchedule.Denom]; ok {
+			return fmt.Errorf("cannot have multiple vesting schedules for %s", vestingSchedule.Denom)
+		}
+
 		if err := vestingSchedule.Validate(); err != nil {
 			return err
 		}
+
+		denomMap[vestingSchedule.Denom] = true
 	}
 
 	return lgva.BaseVestingAccount.Validate()
diff --git a/x/vesting/types/vesting_account_test.go b/x/vesting/types/vesting_account_test.go
index 996f8df2a..884bc2b34 100644
--- a/x/vesting/types/vesting_account_test.go
+++ b/x/vesting/types/vesting_account_test.go
@@ -316,6 +316,14 @@ func TestGenesisAccountValidate(t *testing.T) {
 			types.NewLazyGradedVestingAccount(baseAcc, initialVesting, types.VestingSchedules{types.VestingSchedule{core.MicroLunaDenom, types.Schedules{types.Schedule{1554668078, 1654668078, sdk.NewDecWithPrec(1, 1)}}}}),
 			errors.New("vesting total ratio must be one"),
 		},
+		{
+			"multiple vesting schedule for a denom",
+			types.NewLazyGradedVestingAccount(baseAcc, initialVesting, types.VestingSchedules{
+				{core.MicroLunaDenom, types.Schedules{types.Schedule{1554668078, 1654668078, sdk.OneDec()}}},
+				{core.MicroLunaDenom, types.Schedules{types.Schedule{1554668078, 1654668078, sdk.OneDec()}}},
+			}),
+			errors.New("cannot have multiple vesting schedules for uluna"),
+		},
 	}
 	for _, tt := range tests {
 		tt := tt
diff --git a/x/wasm/keeper/api.go b/x/wasm/keeper/api.go
index b19134ffb..973fa7f86 100644
--- a/x/wasm/keeper/api.go
+++ b/x/wasm/keeper/api.go
@@ -11,20 +11,22 @@ import (
 func (k Keeper) getCosmWasmAPI(ctx sdk.Context) cosmwasm.GoAPI {
 	return cosmwasm.GoAPI{
 		HumanAddress: func(canon []byte) (humanAddr string, usedGas uint64, err error) {
+			humanizeCost := types.HumanizeCost * types.GasMultiplier
 			err = sdk.VerifyAddressFormat(canon)
 			if err != nil {
-				return "", 0, nil
+				return "", humanizeCost, nil
 			}
 
-			return sdk.AccAddress(canon).String(), types.HumanizeCost * types.GasMultiplier, nil
+			return sdk.AccAddress(canon).String(), humanizeCost, nil
 		},
 		CanonicalAddress: func(human string) (canonicalAddr []byte, usedGas uint64, err error) {
+			canonicalizeCost := types.CanonicalizeCost * types.GasMultiplier
 			addr, err := sdk.AccAddressFromBech32(human)
 			if err != nil {
-				return nil, 0, err
+				return nil, canonicalizeCost, err
 			}
 
-			return addr, types.CanonicalizeCost * types.GasMultiplier, nil
+			return addr, canonicalizeCost, nil
 		},
 	}
 }
diff --git a/x/wasm/types/tx.pb.go b/x/wasm/types/tx.pb.go
index 873093ec5..99bbb56cd 100644
--- a/x/wasm/types/tx.pb.go
+++ b/x/wasm/types/tx.pb.go
@@ -38,8 +38,6 @@ type MsgStoreCode struct {
 	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
 	// WASMByteCode can be raw or gzip compressed
 	WASMByteCode []byte `protobuf:"bytes,2,opt,name=wasm_byte_code,json=wasmByteCode,proto3" json:"wasm_byte_code,omitempty" yaml:"wasm_byte_code"`
-	// CodeID is optional
-	CodeID uint64 `protobuf:"varint,3,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty" yaml:"code_id"`
 }
 
 func (m *MsgStoreCode) Reset()         { *m = MsgStoreCode{} }
@@ -670,67 +668,66 @@ func init() {
 func init() { proto.RegisterFile("terra/wasm/v1beta1/tx.proto", fileDescriptor_5834e4e1a84cce82) }
 
 var fileDescriptor_5834e4e1a84cce82 = []byte{
-	// 952 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x41, 0x6f, 0xe3, 0x44,
+	// 944 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x6f, 0xe3, 0x44,
 	0x14, 0x8e, 0x9b, 0xb6, 0xdb, 0xbc, 0x84, 0xb6, 0xeb, 0x76, 0x21, 0x64, 0x21, 0x13, 0xcd, 0x4a,
 	0xab, 0x14, 0x69, 0x6d, 0xb5, 0x88, 0xcb, 0x9e, 0x48, 0xca, 0x22, 0x15, 0xc9, 0x20, 0xb9, 0x42,
 	0x2b, 0x21, 0xa1, 0xc8, 0xb1, 0x47, 0xc6, 0xb0, 0xf1, 0x14, 0x8f, 0x4b, 0x1a, 0x2e, 0x5c, 0xb9,
-	0x20, 0xc1, 0x3f, 0xd8, 0x33, 0x07, 0x7e, 0x04, 0xa7, 0x95, 0x10, 0xd2, 0x1e, 0x39, 0x19, 0x94,
-	0x5e, 0x38, 0x5b, 0xe2, 0x00, 0x27, 0xe4, 0x99, 0xb1, 0x3b, 0x69, 0x92, 0x26, 0xe9, 0x9e, 0x6c,
-	0xbd, 0xf7, 0xcd, 0x7b, 0x33, 0xdf, 0x37, 0xdf, 0xcc, 0xc0, 0xfd, 0x98, 0x44, 0x91, 0x63, 0x0e,
-	0x1d, 0x36, 0x30, 0xbf, 0x39, 0xec, 0x93, 0xd8, 0x39, 0x34, 0xe3, 0x0b, 0xe3, 0x2c, 0xa2, 0x31,
-	0xd5, 0x75, 0x9e, 0x34, 0xb2, 0xa4, 0x21, 0x93, 0x8d, 0x7d, 0x9f, 0xfa, 0x94, 0xa7, 0xcd, 0xec,
-	0x4f, 0x20, 0x1b, 0x4d, 0x97, 0xb2, 0x01, 0x65, 0x66, 0xdf, 0x61, 0xa4, 0xa8, 0xe3, 0xd2, 0x20,
-	0x14, 0x79, 0xfc, 0x9b, 0x06, 0x35, 0x8b, 0xf9, 0xa7, 0x31, 0x8d, 0xc8, 0x31, 0xf5, 0x88, 0x7e,
-	0x00, 0x9b, 0x8c, 0x84, 0x1e, 0x89, 0xea, 0x5a, 0x4b, 0x6b, 0x57, 0xba, 0x77, 0xd3, 0x04, 0xbd,
-	0x36, 0x72, 0x06, 0xcf, 0x1e, 0x63, 0x11, 0xc7, 0xb6, 0x04, 0xe8, 0x9f, 0xc0, 0x76, 0x36, 0x83,
-	0x5e, 0x7f, 0x14, 0x93, 0x9e, 0x4b, 0x3d, 0x52, 0x5f, 0x6b, 0x69, 0xed, 0x5a, 0xf7, 0x60, 0x9c,
-	0xa0, 0xda, 0xd3, 0xce, 0xa9, 0xd5, 0x1d, 0xc5, 0xbc, 0x68, 0x9a, 0xa0, 0x7b, 0xa2, 0xc4, 0x24,
-	0x1e, 0xdb, 0xb5, 0x2c, 0x90, 0xc3, 0xf4, 0xf7, 0xe0, 0x4e, 0x16, 0xee, 0x05, 0x5e, 0xbd, 0xdc,
-	0xd2, 0xda, 0xeb, 0xdd, 0xb7, 0xc6, 0x09, 0xda, 0xcc, 0x52, 0x27, 0x1f, 0xa4, 0x09, 0xda, 0x16,
-	0x35, 0x24, 0x04, 0xdb, 0x9b, 0xd9, 0xdf, 0x89, 0xf7, 0x78, 0xeb, 0xfb, 0xe7, 0xa8, 0xf4, 0xf7,
-	0x73, 0x54, 0xc2, 0x16, 0xec, 0xab, 0x8b, 0xb1, 0x09, 0x3b, 0xa3, 0x21, 0x9b, 0x28, 0xac, 0x2d,
-	0x5f, 0x18, 0xff, 0xae, 0xc1, 0xb6, 0xc5, 0x7c, 0x2b, 0xf0, 0x23, 0x67, 0x7a, 0x8a, 0x2b, 0x54,
-	0x52, 0x58, 0x5d, 0x5b, 0x9d, 0xd5, 0xf2, 0x2b, 0xb1, 0xaa, 0xd0, 0x53, 0x87, 0xd7, 0x27, 0x97,
-	0x93, 0x13, 0x84, 0xff, 0x5d, 0xe3, 0xa9, 0x93, 0x90, 0xc5, 0x4e, 0x18, 0x07, 0x3c, 0x1d, 0xc6,
-	0x91, 0xe3, 0xc6, 0xab, 0x6c, 0x88, 0x87, 0xb0, 0xe1, 0x78, 0x83, 0x20, 0x94, 0x8b, 0xdc, 0x4d,
-	0x13, 0x54, 0x13, 0x48, 0x1e, 0xc6, 0xb6, 0x48, 0xdf, 0x52, 0x67, 0xfd, 0x23, 0xd8, 0x0a, 0xc2,
-	0x20, 0xee, 0x0d, 0x98, 0x5f, 0x5f, 0xe7, 0x9c, 0x98, 0x69, 0x82, 0x76, 0x04, 0x3a, 0xcf, 0xe0,
-	0xff, 0x12, 0x54, 0x27, 0xa1, 0x4b, 0xbd, 0x20, 0xf4, 0xcd, 0x2f, 0x19, 0x0d, 0x0d, 0xdb, 0x19,
-	0x5a, 0x84, 0x31, 0xc7, 0x27, 0xf6, 0x9d, 0x0c, 0x66, 0x31, 0x5f, 0xff, 0x0e, 0x80, 0x8f, 0xc8,
-	0xac, 0xc0, 0xea, 0x1b, 0xad, 0x72, 0xbb, 0x7a, 0xf4, 0xa6, 0x21, 0xcc, 0x62, 0x64, 0x66, 0xc9,
-	0x7d, 0x65, 0x1c, 0xd3, 0x20, 0xec, 0x3e, 0x79, 0x91, 0xa0, 0x52, 0x9a, 0xa0, 0xbb, 0x4a, 0x33,
-	0x3e, 0x14, 0xff, 0xfc, 0x27, 0x6a, 0xfb, 0x41, 0xfc, 0xc5, 0x79, 0xdf, 0x70, 0xe9, 0xc0, 0x94,
-	0x76, 0x13, 0x9f, 0x47, 0xcc, 0xfb, 0xca, 0x8c, 0x47, 0x67, 0x84, 0xf1, 0x2a, 0xcc, 0xae, 0x64,
-	0x03, 0xf9, 0xaf, 0xa2, 0xca, 0x0f, 0x1a, 0x34, 0x67, 0x73, 0x5f, 0xec, 0xdf, 0x0f, 0x61, 0xd7,
-	0x95, 0xb1, 0x9e, 0xe3, 0x79, 0x11, 0x61, 0x4c, 0xaa, 0x71, 0x3f, 0x4d, 0xd0, 0x1b, 0x39, 0x5f,
-	0x93, 0x08, 0x6c, 0xef, 0xe4, 0xa1, 0x8e, 0x88, 0xe8, 0x0f, 0x60, 0xdd, 0x73, 0x62, 0x47, 0xfa,
-	0x74, 0x27, 0x4d, 0x50, 0x55, 0x8c, 0xcd, 0xa2, 0xd8, 0xe6, 0x49, 0xfc, 0xeb, 0x1a, 0xe8, 0x16,
-	0xf3, 0x9f, 0x5c, 0x10, 0xf7, 0xfc, 0x76, 0xfb, 0xc0, 0x84, 0xad, 0xbc, 0xb3, 0xdc, 0x0a, 0x7b,
-	0x57, 0x42, 0xe5, 0x19, 0x6c, 0x17, 0x20, 0xfd, 0x14, 0xaa, 0x44, 0xb4, 0xe3, 0xe2, 0x8a, 0x0d,
-	0x7f, 0x94, 0x26, 0x48, 0x17, 0x63, 0x94, 0xe4, 0xcd, 0xfa, 0x82, 0x44, 0x66, 0x12, 0x7f, 0x0d,
-	0x1b, 0x4b, 0xaa, 0xfb, 0xbe, 0x54, 0xb7, 0x96, 0xcf, 0x70, 0x65, 0x61, 0x45, 0x27, 0x45, 0xd4,
-	0x0e, 0x34, 0xa6, 0x39, 0x2c, 0xf4, 0xcc, 0x75, 0xd0, 0x6e, 0xd2, 0xe1, 0x27, 0xa1, 0x43, 0x61,
-	0x57, 0xc9, 0x55, 0x61, 0x32, 0xed, 0x66, 0x93, 0xad, 0x2c, 0xc2, 0x31, 0x54, 0x43, 0x32, 0xec,
-	0x4d, 0x3a, 0xf3, 0xc1, 0x38, 0x41, 0x95, 0x8f, 0xc9, 0xb0, 0x30, 0xa7, 0x54, 0x44, 0x41, 0x62,
-	0xbb, 0x12, 0x4a, 0x80, 0x97, 0x29, 0x39, 0x10, 0x13, 0x56, 0x6c, 0xaa, 0x28, 0xa9, 0x24, 0x17,
-	0x28, 0x29, 0x91, 0x16, 0xf3, 0xa7, 0x68, 0xbd, 0x46, 0xc9, 0x6a, 0xb4, 0xfe, 0xa2, 0xf1, 0xa3,
-	0xee, 0xd3, 0x33, 0x4f, 0x29, 0xd1, 0xe1, 0x94, 0x2d, 0x4b, 0xed, 0x21, 0x64, 0x2b, 0xee, 0xa9,
-	0x67, 0xdd, 0x7e, 0x9a, 0xa0, 0xdd, 0x2b, 0x6a, 0x24, 0x7e, 0x2b, 0x24, 0xc3, 0xce, 0x94, 0x1a,
-	0xe5, 0x25, 0xd4, 0x50, 0xd6, 0xdc, 0xe2, 0xc7, 0xc3, 0x8c, 0xf9, 0x16, 0xa7, 0xf7, 0xb7, 0x70,
-	0xcf, 0x62, 0xfe, 0xf1, 0x33, 0xe2, 0x44, 0xb7, 0x5b, 0xd0, 0xaa, 0x7b, 0x45, 0x99, 0x1d, 0x82,
-	0xb7, 0x67, 0xf6, 0xce, 0x27, 0x77, 0xf4, 0xcf, 0x06, 0x94, 0x33, 0x3b, 0x3e, 0x85, 0xca, 0xd5,
-	0x2b, 0xa3, 0x65, 0x4c, 0xbf, 0x60, 0x0c, 0xf5, 0xea, 0x6e, 0xb4, 0x17, 0x21, 0x0a, 0xd5, 0x3f,
-	0x87, 0xaa, 0x7a, 0x43, 0xe3, 0x39, 0x03, 0x15, 0x4c, 0xe3, 0x9d, 0xc5, 0x98, 0xa2, 0xfc, 0x39,
-	0xec, 0xcd, 0xba, 0x16, 0xe7, 0x95, 0x98, 0x81, 0x6d, 0x1c, 0x2d, 0x8f, 0x2d, 0xda, 0x06, 0xb0,
-	0x73, 0xfd, 0x04, 0x7e, 0x38, 0xa7, 0xcc, 0x35, 0x5c, 0xc3, 0x58, 0x0e, 0xa7, 0xb6, 0x9a, 0x3a,
-	0x64, 0x16, 0x11, 0xb4, 0xa0, 0xd5, 0x3c, 0x87, 0x9e, 0xc3, 0xde, 0x2c, 0xe3, 0xcd, 0x23, 0x73,
-	0x06, 0x76, 0x2e, 0x99, 0x37, 0x18, 0x44, 0x8f, 0x40, 0x9f, 0xe1, 0x8e, 0x83, 0x39, 0x95, 0xa6,
-	0xa1, 0x8d, 0xc3, 0xa5, 0xa1, 0x79, 0xcf, 0x6e, 0xf7, 0xc5, 0xb8, 0xa9, 0xbd, 0x1c, 0x37, 0xb5,
-	0xbf, 0xc6, 0x4d, 0xed, 0xc7, 0xcb, 0x66, 0xe9, 0xe5, 0x65, 0xb3, 0xf4, 0xc7, 0x65, 0xb3, 0xf4,
-	0x99, 0x7a, 0xad, 0xf0, 0xb2, 0x8f, 0x06, 0x34, 0x24, 0x23, 0xd3, 0xa5, 0x11, 0x31, 0x2f, 0xc4,
-	0x93, 0x9f, 0x5f, 0x2e, 0xfd, 0x4d, 0xfe, 0x48, 0x7f, 0xf7, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0x02, 0xca, 0xd7, 0x2d, 0x0d, 0x0c, 0x00, 0x00,
+	0x20, 0x81, 0xc4, 0x1f, 0xb0, 0x67, 0x0e, 0xfc, 0x11, 0x9c, 0xf6, 0x82, 0xb4, 0x47, 0x4e, 0x06,
+	0xa5, 0x17, 0xce, 0x96, 0x38, 0xc0, 0x09, 0x79, 0x66, 0xec, 0x4e, 0x9b, 0xdf, 0xd5, 0x9e, 0x6c,
+	0xcd, 0xfb, 0xde, 0x8f, 0xf9, 0xbe, 0xf7, 0x66, 0x06, 0xee, 0xc7, 0x24, 0x8a, 0x1c, 0x73, 0xe8,
+	0xb0, 0x81, 0xf9, 0xcd, 0x61, 0x9f, 0xc4, 0xce, 0xa1, 0x19, 0x5f, 0x18, 0x67, 0x11, 0x8d, 0xa9,
+	0xae, 0x73, 0xa3, 0x91, 0x19, 0x0d, 0x69, 0x6c, 0xec, 0xfb, 0xd4, 0xa7, 0xdc, 0x6c, 0x66, 0x7f,
+	0x02, 0xd9, 0x68, 0xba, 0x94, 0x0d, 0x28, 0x33, 0xfb, 0x0e, 0x23, 0x45, 0x1c, 0x97, 0x06, 0xa1,
+	0xb0, 0xe3, 0x9f, 0x35, 0xa8, 0x59, 0xcc, 0x3f, 0x8d, 0x69, 0x44, 0x8e, 0xa9, 0x47, 0xf4, 0x03,
+	0xd8, 0x64, 0x24, 0xf4, 0x48, 0x54, 0xd7, 0x5a, 0x5a, 0xbb, 0xd2, 0xbd, 0x9b, 0x26, 0xe8, 0xb5,
+	0x91, 0x33, 0x78, 0xf6, 0x18, 0x8b, 0x75, 0x6c, 0x4b, 0x80, 0xfe, 0x09, 0x6c, 0x67, 0x15, 0xf4,
+	0xfa, 0xa3, 0x98, 0xf4, 0x5c, 0xea, 0x91, 0xfa, 0x5a, 0x4b, 0x6b, 0xd7, 0xba, 0x07, 0xe3, 0x04,
+	0xd5, 0x9e, 0x76, 0x4e, 0xad, 0xee, 0x28, 0xe6, 0x41, 0xd3, 0x04, 0xdd, 0x13, 0x21, 0xae, 0xe3,
+	0xb1, 0x5d, 0xcb, 0x16, 0x72, 0xd8, 0xe3, 0xad, 0xef, 0x9f, 0xa3, 0xd2, 0xdf, 0xcf, 0x51, 0x09,
+	0x5b, 0xb0, 0xaf, 0x56, 0x65, 0x13, 0x76, 0x46, 0x43, 0x46, 0xf4, 0xf7, 0xe0, 0x4e, 0xe6, 0xd8,
+	0x0b, 0x3c, 0x5e, 0xde, 0x7a, 0xf7, 0xad, 0x71, 0x82, 0x36, 0x33, 0xc8, 0xc9, 0x07, 0x69, 0x82,
+	0xb6, 0x45, 0x16, 0x09, 0xc1, 0xf6, 0x66, 0xf6, 0x77, 0xe2, 0xe1, 0xdf, 0x35, 0xd8, 0xb6, 0x98,
+	0x6f, 0x05, 0x7e, 0xe4, 0x88, 0x5c, 0xb7, 0x8c, 0xa4, 0xd0, 0xb3, 0xb6, 0x3a, 0x3d, 0xe5, 0x57,
+	0x45, 0x4f, 0x1d, 0x5e, 0xbf, 0xbe, 0x9d, 0x9c, 0x20, 0xfc, 0xef, 0x1a, 0x37, 0x9d, 0x84, 0x2c,
+	0x76, 0xc2, 0x38, 0xe0, 0xe6, 0x30, 0x8e, 0x1c, 0x37, 0x5e, 0x45, 0xd9, 0x87, 0xb0, 0xe1, 0x78,
+	0x83, 0x20, 0x94, 0x9b, 0xdc, 0x4d, 0x13, 0x54, 0x13, 0x48, 0xbe, 0x8c, 0x6d, 0x61, 0x56, 0x49,
+	0x2c, 0xaf, 0x40, 0xe2, 0x47, 0xb0, 0x15, 0x84, 0x41, 0xdc, 0x1b, 0x30, 0xbf, 0xbe, 0xce, 0x39,
+	0x31, 0xd3, 0x04, 0xed, 0x08, 0x74, 0x6e, 0xc1, 0xff, 0x25, 0xa8, 0x4e, 0x42, 0x97, 0x7a, 0x41,
+	0xe8, 0x9b, 0x5f, 0x32, 0x1a, 0x1a, 0xb6, 0x33, 0xb4, 0x08, 0x63, 0x8e, 0x4f, 0xec, 0x3b, 0x19,
+	0xcc, 0x62, 0xbe, 0xfe, 0x1d, 0x00, 0xf7, 0xc8, 0x7a, 0x9a, 0xd5, 0x37, 0x5a, 0xe5, 0x76, 0xf5,
+	0xe8, 0x4d, 0x43, 0x74, 0xbd, 0x91, 0x75, 0x7d, 0x3e, 0x20, 0xc6, 0x31, 0x0d, 0xc2, 0xee, 0x93,
+	0x17, 0x09, 0x2a, 0xa5, 0x09, 0xba, 0xab, 0x24, 0xe3, 0xae, 0xf8, 0x97, 0x3f, 0x51, 0xdb, 0x0f,
+	0xe2, 0x2f, 0xce, 0xfb, 0x86, 0x4b, 0x07, 0xa6, 0x9c, 0x1b, 0xf1, 0x79, 0xc4, 0xbc, 0xaf, 0xcc,
+	0x78, 0x74, 0x46, 0x18, 0x8f, 0xc2, 0xec, 0x4a, 0xe6, 0xc8, 0x7f, 0x15, 0x55, 0x7e, 0xd0, 0xa0,
+	0x39, 0x9d, 0xfb, 0xa2, 0x7f, 0x3f, 0x84, 0x5d, 0x57, 0xae, 0xf5, 0x1c, 0xcf, 0x8b, 0x08, 0x63,
+	0x52, 0x8d, 0xfb, 0x69, 0x82, 0xde, 0xc8, 0xf9, 0xba, 0x8e, 0xc0, 0xf6, 0x4e, 0xbe, 0xd4, 0x11,
+	0x2b, 0xfa, 0x03, 0x58, 0xf7, 0x9c, 0xd8, 0x91, 0x03, 0xb7, 0x93, 0x26, 0xa8, 0x2a, 0x7c, 0xb3,
+	0x55, 0x6c, 0x73, 0x23, 0xfe, 0x6d, 0x0d, 0x74, 0x8b, 0xf9, 0x4f, 0x2e, 0x88, 0x7b, 0x7e, 0xbb,
+	0x3e, 0x30, 0x61, 0x2b, 0xcf, 0x2c, 0x5b, 0x61, 0xef, 0x4a, 0xa8, 0xdc, 0x82, 0xed, 0x02, 0xa4,
+	0x9f, 0x42, 0x95, 0x88, 0x74, 0x5c, 0x5c, 0xd1, 0xf0, 0x47, 0x69, 0x82, 0x74, 0xe1, 0xa3, 0x18,
+	0xe7, 0xeb, 0x0b, 0x12, 0x99, 0x49, 0xfc, 0x35, 0x6c, 0x2c, 0xa9, 0xee, 0xfb, 0x52, 0xdd, 0x5a,
+	0x5e, 0xe1, 0xca, 0xc2, 0x8a, 0x4c, 0x8a, 0xa8, 0x1d, 0x68, 0x4c, 0x72, 0x58, 0xe8, 0x99, 0xeb,
+	0xa0, 0xcd, 0xd3, 0xe1, 0x27, 0xa1, 0x43, 0x31, 0xae, 0x92, 0xab, 0x62, 0xc8, 0xb4, 0xf9, 0x43,
+	0xb6, 0xb2, 0x08, 0xc7, 0x50, 0x0d, 0xc9, 0xb0, 0x77, 0x7d, 0x32, 0x1f, 0x8c, 0x13, 0x54, 0xf9,
+	0x98, 0x0c, 0x8b, 0xe1, 0x94, 0x8a, 0x28, 0x48, 0x6c, 0x57, 0x42, 0x09, 0xf0, 0x32, 0x25, 0x07,
+	0xa2, 0x60, 0x65, 0x4c, 0x15, 0x25, 0x15, 0xe3, 0x02, 0x25, 0x25, 0xd2, 0x62, 0xfe, 0x04, 0xad,
+	0x37, 0x28, 0x59, 0x8d, 0xd6, 0x5f, 0x35, 0x7e, 0xd4, 0x7d, 0x7a, 0xe6, 0x29, 0x21, 0x3a, 0x9c,
+	0xb2, 0x65, 0xa9, 0x3d, 0x84, 0x6c, 0xc7, 0x3d, 0xf5, 0xac, 0xdb, 0x4f, 0x13, 0xb4, 0x7b, 0x45,
+	0x8d, 0xc4, 0x6f, 0x85, 0x64, 0xd8, 0x99, 0x50, 0xa3, 0xbc, 0x84, 0x1a, 0xca, 0x9e, 0x5b, 0xfc,
+	0x78, 0x98, 0x52, 0x6f, 0x71, 0x7a, 0x7f, 0x0b, 0xf7, 0x2c, 0xe6, 0x1f, 0x3f, 0x23, 0x4e, 0x74,
+	0xbb, 0x0d, 0xad, 0xda, 0x2b, 0x4a, 0x75, 0x08, 0xde, 0x9e, 0x9a, 0x3b, 0x2f, 0xee, 0xe8, 0x9f,
+	0x0d, 0x28, 0x67, 0xe3, 0xf8, 0x14, 0x2a, 0x57, 0xcf, 0x85, 0x96, 0x31, 0xf9, 0x14, 0x31, 0xd4,
+	0xab, 0xbb, 0xd1, 0x5e, 0x84, 0x28, 0x54, 0xff, 0x1c, 0xaa, 0xea, 0x0d, 0x8d, 0x67, 0x38, 0x2a,
+	0x98, 0xc6, 0x3b, 0x8b, 0x31, 0x45, 0xf8, 0x73, 0xd8, 0x9b, 0x76, 0x2d, 0xce, 0x0a, 0x31, 0x05,
+	0xdb, 0x38, 0x5a, 0x1e, 0x5b, 0xa4, 0x0d, 0x60, 0xe7, 0xe6, 0x09, 0xfc, 0x70, 0x46, 0x98, 0x1b,
+	0xb8, 0x86, 0xb1, 0x1c, 0x4e, 0x4d, 0x35, 0x71, 0xc8, 0x2c, 0x22, 0x68, 0x41, 0xaa, 0x59, 0x13,
+	0x7a, 0x0e, 0x7b, 0xd3, 0x06, 0x6f, 0x16, 0x99, 0x53, 0xb0, 0x33, 0xc9, 0x9c, 0x33, 0x20, 0x7a,
+	0x04, 0xfa, 0x94, 0xe9, 0x38, 0x98, 0x11, 0x69, 0x12, 0xda, 0x38, 0x5c, 0x1a, 0x9a, 0xe7, 0xec,
+	0x76, 0x5f, 0x8c, 0x9b, 0xda, 0xcb, 0x71, 0x53, 0xfb, 0x6b, 0xdc, 0xd4, 0x7e, 0xbc, 0x6c, 0x96,
+	0x5e, 0x5e, 0x36, 0x4b, 0x7f, 0x5c, 0x36, 0x4b, 0x9f, 0xa9, 0xd7, 0x0a, 0x0f, 0xfb, 0x68, 0x40,
+	0x43, 0x32, 0x32, 0x5d, 0x1a, 0x11, 0xf3, 0x42, 0xbc, 0xdd, 0xf9, 0xe5, 0xd2, 0xdf, 0xe4, 0xaf,
+	0xed, 0x77, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xfa, 0xdf, 0x2a, 0xed, 0xd6, 0x0b, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1063,11 +1060,6 @@ func (m *MsgStoreCode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.CodeID != 0 {
-		i = encodeVarintTx(dAtA, i, uint64(m.CodeID))
-		i--
-		dAtA[i] = 0x18
-	}
 	if len(m.WASMByteCode) > 0 {
 		i -= len(m.WASMByteCode)
 		copy(dAtA[i:], m.WASMByteCode)
@@ -1597,9 +1589,6 @@ func (m *MsgStoreCode) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTx(uint64(l))
 	}
-	if m.CodeID != 0 {
-		n += 1 + sovTx(uint64(m.CodeID))
-	}
 	return n
 }
 
@@ -1925,25 +1914,6 @@ func (m *MsgStoreCode) Unmarshal(dAtA []byte) error {
 				m.WASMByteCode = []byte{}
 			}
 			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType)
-			}
-			m.CodeID = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.CodeID |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTx(dAtA[iNdEx:])