Repository: desmos-labs/desmos
Pull request #552 (2021-07-12 07:38:44)

Improved the YAML tags of Proto files


<!-- < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < ☺
v                               ✰  Thanks for creating a PR! ✰    
v    Before smashing the submit button please review the checkboxes.
v    If a checkbox is n/a - please still include it but + a little note why
☺ > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >  -->

## Description
This PR improves the YAML tags of Proto files

## Checklist
- [ ] Targeted PR against correct branch.
- [ ] Linked to Github issue with discussion and accepted design OR link to spec that describes this work.
- [ ] Wrote unit tests.
- [ ] Wrote integration tests (simulation & CLI). 
- [ ] Updated the documentation. 
- [ ] Added an entry to the `CHANGELOG.md` file.
- [ ] Re-reviewed `Files changed` in the Github PR explorer.


codecov[bot]: # [Codecov](https://codecov.io/gh/desmos-labs/desmos/pull/552?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs) Report
> Merging [#552](https://codecov.io/gh/desmos-labs/desmos/pull/552?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs) (4081fb0) into [master](https://codecov.io/gh/desmos-labs/desmos/commit/16e1eeb007f568430d34e82c151d2f49ad1f6d19?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs) (16e1eeb) will **increase** coverage by `7.08%`.
> The diff coverage is `72.04%`.

[![Impacted file tree graph](https://codecov.io/gh/desmos-labs/desmos/pull/552/graphs/tree.svg?width=650&height=150&src=pr&token=c87ulmWL91&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs)](https://codecov.io/gh/desmos-labs/desmos/pull/552?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs)

```diff
@@            Coverage Diff             @@
##           master     #552      +/-   ##
==========================================
+ Coverage   75.59%   82.67%   +7.08%     
==========================================
  Files          94       91       -3     
  Lines        4519     5426     +907     
==========================================
+ Hits         3416     4486    +1070     
+ Misses        960      738     -222     
- Partials      143      202      +59     
```


| [Impacted Files](https://codecov.io/gh/desmos-labs/desmos/pull/552?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs) | Coverage Δ | |
|---|---|---|
| [app/desmos/cmd/root.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-YXBwL2Rlc21vcy9jbWQvcm9vdC5nbw==) | `0.00% <0.00%> (ø)` | |
| [x/commons/commons.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9jb21tb25zL2NvbW1vbnMuZ28=) | `100.00% <ø> (ø)` | |
| [x/profiles/keeper/msg\_server\_app\_link.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9wcm9maWxlcy9rZWVwZXIvbXNnX3NlcnZlcl9hcHBfbGluay5nbw==) | `0.00% <0.00%> (ø)` | |
| [x/profiles/keeper/relay\_app\_links.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9wcm9maWxlcy9rZWVwZXIvcmVsYXlfYXBwX2xpbmtzLmdv) | `95.31% <ø> (ø)` | |
| [x/profiles/keeper/relay\_chain\_links.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9wcm9maWxlcy9rZWVwZXIvcmVsYXlfY2hhaW5fbGlua3MuZ28=) | `87.09% <ø> (+0.43%)` | :arrow_up: |
| [x/profiles/simulation/decoder.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9wcm9maWxlcy9zaW11bGF0aW9uL2RlY29kZXIuZ28=) | `63.15% <ø> (-28.85%)` | :arrow_down: |
| [x/profiles/types/account.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9wcm9maWxlcy90eXBlcy9hY2NvdW50Lmdv) | `57.04% <ø> (+5.63%)` | :arrow_up: |
| [x/profiles/types/codec.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9wcm9maWxlcy90eXBlcy9jb2RlYy5nbw==) | `100.00% <ø> (ø)` | |
| [x/profiles/types/genesis.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9wcm9maWxlcy90eXBlcy9nZW5lc2lzLmdv) | `95.74% <ø> (+9.53%)` | :arrow_up: |
| [x/profiles/types/models\_app\_links.go](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs#diff-eC9wcm9maWxlcy90eXBlcy9tb2RlbHNfYXBwX2xpbmtzLmdv) | `92.38% <ø> (ø)` | |
| ... and [134 more](https://codecov.io/gh/desmos-labs/desmos/pull/552/diff?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs) | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/desmos-labs/desmos/pull/552?src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/desmos-labs/desmos/pull/552?src=pr&el=footer&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs). Last update [fba1f05...4081fb0](https://codecov.io/gh/desmos-labs/desmos/pull/552?src=pr&el=lastupdated&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=desmos-labs).


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ce6214dd..9df99ad1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Improved pagination ([#544](https://github.com/desmos-labs/desmos/pull/544))
 - Renamed `PollData` and `PollAnswer` to `Poll` and `ProvidedAnswer` ([#536]((https://github.com/desmos-labs/desmos/issues/536)))
 - Enabled snapshot by default ([#529](https://github.com/desmos-labs/desmos/pull/529))
+- Improved `x/profiles` params structure [#538](https://github.com/desmos-labs/desmos/issues/538)
 
 ## Version 0.17.0
 ### Changes
diff --git a/proto/desmos/posts/v1beta1/polls.proto b/proto/desmos/posts/v1beta1/polls.proto
index 7d641a96..cb42b3e7 100644
--- a/proto/desmos/posts/v1beta1/polls.proto
+++ b/proto/desmos/posts/v1beta1/polls.proto
@@ -6,7 +6,8 @@ import "google/protobuf/timestamp.proto";
 
 option go_package = "github.com/desmos-labs/desmos/x/staging/posts/types";
 
-// ProvidedAnswer contains the data of a single poll answer inserted by the creator
+// ProvidedAnswer contains the data of a single poll answer inserted by the
+// creator
 message ProvidedAnswer {
   option (gogoproto.equal) = true;
   option (gogoproto.goproto_stringer) = true;
diff --git a/proto/desmos/profiles/v1beta1/genesis.proto b/proto/desmos/profiles/v1beta1/genesis.proto
index a6e4569b..fd7aee29 100644
--- a/proto/desmos/profiles/v1beta1/genesis.proto
+++ b/proto/desmos/profiles/v1beta1/genesis.proto
@@ -23,12 +23,12 @@ message GenesisState {
       ];
 
   repeated desmos.profiles.v1beta1.Relationship relationships = 2 [
-    (gogoproto.moretags) = "yaml:\"users_relationships\"",
+    (gogoproto.moretags) = "yaml:\"relationships\"",
     (gogoproto.nullable) = false
   ];
 
   repeated desmos.profiles.v1beta1.UserBlock blocks = 3 [
-    (gogoproto.moretags) = "yaml:\"users_blocks\"",
+    (gogoproto.moretags) = "yaml:\"blocks\"",
     (gogoproto.nullable) = false
   ];
 
@@ -42,9 +42,13 @@ message GenesisState {
     (gogoproto.customname) = "IBCPortID"
   ];
 
-  repeated desmos.profiles.v1beta1.ChainLink chain_links = 6
-      [ (gogoproto.nullable) = false ];
+  repeated desmos.profiles.v1beta1.ChainLink chain_links = 6 [
+    (gogoproto.nullable) = false,
+    (gogoproto.moretags) = "yaml:\"chain_links\""
+  ];
 
-  repeated ApplicationLink application_links = 7
-      [ (gogoproto.nullable) = false ];
+  repeated ApplicationLink application_links = 7 [
+    (gogoproto.nullable) = false,
+    (gogoproto.moretags) = "yaml:\"application_links\""
+  ];
 }
diff --git a/proto/desmos/profiles/v1beta1/models_params.proto b/proto/desmos/profiles/v1beta1/models_params.proto
index e996da00..e51cec66 100644
--- a/proto/desmos/profiles/v1beta1/models_params.proto
+++ b/proto/desmos/profiles/v1beta1/models_params.proto
@@ -9,38 +9,35 @@ option go_package = "github.com/desmos-labs/desmos/x/profiles/types";
 message Params {
   option (gogoproto.goproto_getters) = false;
 
-  NicknameParams nickname_params = 1 [
+  NicknameParams nickname = 1 [
     (gogoproto.nullable) = false,
-    (gogoproto.moretags) = "yaml:\"nickname_params\""
+    (gogoproto.moretags) = "yaml:\"nickname\""
   ];
 
-  DTagParams dtag_params = 2 [
+  DTagParams dtag = 2 [
     (gogoproto.nullable) = false,
-    (gogoproto.moretags) = "yaml:\"dtag_params\"",
-    (gogoproto.customname) = "DTagParams"
+    (gogoproto.moretags) = "yaml:\"dtag\"",
+    (gogoproto.customname) = "DTag"
   ];
 
-  bytes max_bio_length = 3 [
-    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
-    (gogoproto.nullable) = false,
-    (gogoproto.moretags) = "yaml:\"max_bio_length\""
-  ];
+  BioParams bio = 3
+      [ (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"bio\"" ];
 }
 
 // NicknameParams defines the parameters related to the profiles nicknames
 message NicknameParams {
   option (gogoproto.goproto_getters) = false;
 
-  bytes min_nickname_length = 1 [
+  bytes min_length = 1 [
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
     (gogoproto.nullable) = false,
-    (gogoproto.moretags) = "yaml:\"min_nickname_length\""
+    (gogoproto.moretags) = "yaml:\"min_length\""
   ];
 
-  bytes max_nickname_length = 2 [
+  bytes max_length = 2 [
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
     (gogoproto.nullable) = false,
-    (gogoproto.moretags) = "yaml:\"max_nickname_length\""
+    (gogoproto.moretags) = "yaml:\"max_length\""
   ];
 }
 
@@ -50,17 +47,28 @@ message DTagParams {
 
   string reg_ex = 1 [ (gogoproto.moretags) = "yaml:\"reg_ex\"" ];
 
-  bytes min_dtag_length = 2 [
+  bytes min_length = 2 [
+    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
+    (gogoproto.nullable) = false,
+    (gogoproto.moretags) = "yaml:\"min_length\"",
+    (gogoproto.customname) = "MinLength"
+  ];
+
+  bytes max_length = 3 [
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
     (gogoproto.nullable) = false,
-    (gogoproto.moretags) = "yaml:\"min_dtag_length\"",
-    (gogoproto.customname) = "MinDTagLength"
+    (gogoproto.moretags) = "yaml:\"max_length\"",
+    (gogoproto.customname) = "MaxLength"
   ];
+}
+
+// BioParams defines the parameters related to profile biography
+message BioParams {
+  option (gogoproto.goproto_getters) = false;
 
-  bytes max_dtag_length = 3 [
+  bytes max_length = 3 [
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
     (gogoproto.nullable) = false,
-    (gogoproto.moretags) = "yaml:\"max_dtag_length\"",
-    (gogoproto.customname) = "MaxDTagLength"
+    (gogoproto.moretags) = "yaml:\"max_length\""
   ];
 }
diff --git a/proto/desmos/profiles/v1beta1/msgs_dtag_requests.proto b/proto/desmos/profiles/v1beta1/msgs_dtag_requests.proto
index 8447dfb0..97482f4d 100644
--- a/proto/desmos/profiles/v1beta1/msgs_dtag_requests.proto
+++ b/proto/desmos/profiles/v1beta1/msgs_dtag_requests.proto
@@ -44,8 +44,8 @@ message MsgCancelDTagTransferRequest {
   string sender = 2 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
 }
 
-// MsgCancelDTagTransferRequestResponse represents the Msg/CancelDTagTransferRequest
-// response type.
+// MsgCancelDTagTransferRequestResponse represents the
+// Msg/CancelDTagTransferRequest response type.
 message MsgCancelDTagTransferRequestResponse {}
 
 // ___________________________________________________________________________________________________________________
@@ -71,8 +71,8 @@ message MsgAcceptDTagTransferRequest {
   string receiver = 3 [ (gogoproto.moretags) = "yaml:\"receiver\"" ];
 }
 
-// MsgAcceptDTagTransferRequestResponse defines the Msg/AcceptDTagTransferRequest
-// response.
+// MsgAcceptDTagTransferRequestResponse defines the
+// Msg/AcceptDTagTransferRequest response.
 message MsgAcceptDTagTransferRequestResponse {}
 
 // ___________________________________________________________________________________________________________________
@@ -90,6 +90,6 @@ message MsgRefuseDTagTransferRequest {
   string receiver = 2 [ (gogoproto.moretags) = "yaml:\"receiver\"" ];
 }
 
-// MsgRefuseDTagTransferRequestResponse defines the Msg/RefuseDTagTransferRequest
-// response.
+// MsgRefuseDTagTransferRequestResponse defines the
+// Msg/RefuseDTagTransferRequest response.
 message MsgRefuseDTagTransferRequestResponse {}
diff --git a/x/profiles/keeper/keeper.go b/x/profiles/keeper/keeper.go
index 3e8484cb..1631ae2e 100644
--- a/x/profiles/keeper/keeper.go
+++ b/x/profiles/keeper/keeper.go
@@ -168,8 +168,8 @@ func (k Keeper) RemoveProfile(ctx sdk.Context, address string) error {
 func (k Keeper) ValidateProfile(ctx sdk.Context, profile *types.Profile) error {
 	params := k.GetParams(ctx)
 
-	minNicknameLen := params.NicknameParams.MinNicknameLength.Int64()
-	maxNicknameLen := params.NicknameParams.MaxNicknameLength.Int64()
+	minNicknameLen := params.Nickname.MinLength.Int64()
+	maxNicknameLen := params.Nickname.MaxLength.Int64()
 
 	if profile.Nickname != "" {
 		nameLen := int64(len(profile.Nickname))
@@ -181,9 +181,9 @@ func (k Keeper) ValidateProfile(ctx sdk.Context, profile *types.Profile) error {
 		}
 	}
 
-	dTagRegEx := regexp.MustCompile(params.DTagParams.RegEx)
-	minDTagLen := params.DTagParams.MinDTagLength.Int64()
-	maxDTagLen := params.DTagParams.MaxDTagLength.Int64()
+	dTagRegEx := regexp.MustCompile(params.DTag.RegEx)
+	minDTagLen := params.DTag.MinLength.Int64()
+	maxDTagLen := params.DTag.MaxLength.Int64()
 	dTagLen := int64(len(profile.DTag))
 
 	if !dTagRegEx.MatchString(profile.DTag) {
@@ -198,7 +198,7 @@ func (k Keeper) ValidateProfile(ctx sdk.Context, profile *types.Profile) error {
 		return fmt.Errorf("profile dtag cannot exceed %d characters", maxDTagLen)
 	}
 
-	maxBioLen := params.MaxBioLength.Int64()
+	maxBioLen := params.Bio.MaxLength.Int64()
 	if profile.Bio != "" && int64(len(profile.Bio)) > maxBioLen {
 		return fmt.Errorf("profile biography cannot exceed %d characters", maxBioLen)
 	}
diff --git a/x/profiles/legacy/v0160/params.go b/x/profiles/legacy/v0160/params.go
deleted file mode 100644
index 92a6fdd6..00000000
--- a/x/profiles/legacy/v0160/params.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package v0160
-
-// Parameters store keys
-// DONTCOVER
-
-var (
-	MonikerLenParamsKey = []byte("MonikerParams")
-	DTagParamsKey       = []byte("DTagParams")
-	MaxBioLenParamsKey  = []byte("MaxBioLen")
-)
diff --git a/x/profiles/legacy/v0160/params.pb.go b/x/profiles/legacy/v0160/params.pb.go
deleted file mode 100644
index 89411968..00000000
--- a/x/profiles/legacy/v0160/params.pb.go
+++ /dev/null
@@ -1,917 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: desmos/profiles/v1beta1/legacy/v0160/params.proto
-
-package v0160
-
-import (
-	fmt "fmt"
-	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
-	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-// Params contains the parameters for the profiles module
-type Params struct {
-	MonikerParams MonikerParams                          `protobuf:"bytes,1,opt,name=moniker_params,json=monikerParams,proto3" json:"moniker_params" yaml:"moniker_params"`
-	DTagParams    DTagParams                             `protobuf:"bytes,2,opt,name=dtag_params,json=dtagParams,proto3" json:"dtag_params" yaml:"dtag_params"`
-	MaxBioLength  github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=max_bio_length,json=maxBioLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_bio_length" yaml:"max_bio_length"`
-}
-
-func (m *Params) Reset()         { *m = Params{} }
-func (m *Params) String() string { return proto.CompactTextString(m) }
-func (*Params) ProtoMessage()    {}
-func (*Params) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3b77dc1fa804707e, []int{0}
-}
-func (m *Params) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_Params.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *Params) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Params.Merge(m, src)
-}
-func (m *Params) XXX_Size() int {
-	return m.Size()
-}
-func (m *Params) XXX_DiscardUnknown() {
-	xxx_messageInfo_Params.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Params proto.InternalMessageInfo
-
-func (m *Params) GetMonikerParams() MonikerParams {
-	if m != nil {
-		return m.MonikerParams
-	}
-	return MonikerParams{}
-}
-
-func (m *Params) GetDTagParams() DTagParams {
-	if m != nil {
-		return m.DTagParams
-	}
-	return DTagParams{}
-}
-
-// MonikerParams defines the parameters related to the profiles monikers
-type MonikerParams struct {
-	MinMonikerLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=min_moniker_length,json=minMonikerLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_moniker_length" yaml:"min_moniker_length"`
-	MaxMonikerLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=max_moniker_length,json=maxMonikerLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_moniker_length" yaml:"max_moniker_length"`
-}
-
-func (m *MonikerParams) Reset()         { *m = MonikerParams{} }
-func (m *MonikerParams) String() string { return proto.CompactTextString(m) }
-func (*MonikerParams) ProtoMessage()    {}
-func (*MonikerParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3b77dc1fa804707e, []int{1}
-}
-func (m *MonikerParams) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MonikerParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MonikerParams.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *MonikerParams) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MonikerParams.Merge(m, src)
-}
-func (m *MonikerParams) XXX_Size() int {
-	return m.Size()
-}
-func (m *MonikerParams) XXX_DiscardUnknown() {
-	xxx_messageInfo_MonikerParams.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MonikerParams proto.InternalMessageInfo
-
-// DTagParams defines the parameters related to profile DTags
-type DTagParams struct {
-	RegEx         string                                 `protobuf:"bytes,1,opt,name=reg_ex,json=regEx,proto3" json:"reg_ex,omitempty" yaml:"reg_ex"`
-	MinDTagLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=min_dtag_length,json=minDtagLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_dtag_length" yaml:"min_dtag_length"`
-	MaxDTagLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=max_dtag_length,json=maxDtagLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_dtag_length" yaml:"max_dtag_length"`
-}
-
-func (m *DTagParams) Reset()         { *m = DTagParams{} }
-func (m *DTagParams) String() string { return proto.CompactTextString(m) }
-func (*DTagParams) ProtoMessage()    {}
-func (*DTagParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3b77dc1fa804707e, []int{2}
-}
-func (m *DTagParams) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *DTagParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_DTagParams.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *DTagParams) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DTagParams.Merge(m, src)
-}
-func (m *DTagParams) XXX_Size() int {
-	return m.Size()
-}
-func (m *DTagParams) XXX_DiscardUnknown() {
-	xxx_messageInfo_DTagParams.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_DTagParams proto.InternalMessageInfo
-
-func (m *DTagParams) GetRegEx() string {
-	if m != nil {
-		return m.RegEx
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*Params)(nil), "desmos.profiles.v1beta1.legacy.v0160.Params")
-	proto.RegisterType((*MonikerParams)(nil), "desmos.profiles.v1beta1.legacy.v0160.MonikerParams")
-	proto.RegisterType((*DTagParams)(nil), "desmos.profiles.v1beta1.legacy.v0160.DTagParams")
-}
-
-func init() {
-	proto.RegisterFile("desmos/profiles/v1beta1/legacy/v0160/params.proto", fileDescriptor_3b77dc1fa804707e)
-}
-
-var fileDescriptor_3b77dc1fa804707e = []byte{
-	// 498 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xb1, 0x6e, 0xd4, 0x30,
-	0x00, 0x86, 0x2f, 0xa9, 0x38, 0x09, 0xb7, 0x57, 0x20, 0x02, 0x54, 0x90, 0x48, 0xaa, 0x08, 0xa1,
-	0x5b, 0x6a, 0xdf, 0x51, 0xc1, 0xc0, 0x18, 0x15, 0x21, 0x04, 0x15, 0x28, 0x62, 0x81, 0x25, 0x72,
-	0xee, 0x8c, 0x6b, 0x35, 0x8e, 0x4f, 0x49, 0xa8, 0x1c, 0x31, 0x31, 0xb0, 0xf3, 0x44, 0xcc, 0x1d,
-	0x3b, 0x22, 0x86, 0x08, 0xe5, 0x1e, 0x00, 0xe9, 0x9e, 0x00, 0xd9, 0xce, 0x29, 0x09, 0x65, 0x68,
-	0xe9, 0x74, 0x89, 0xe5, 0xff, 0xff, 0x3e, 0xdb, 0x17, 0x83, 0xe9, 0x9c, 0xe4, 0x5c, 0xe4, 0x68,
-	0x91, 0x89, 0x8f, 0x2c, 0x21, 0x39, 0x3a, 0x99, 0xc6, 0xa4, 0xc0, 0x53, 0x94, 0x10, 0x8a, 0x67,
-	0x25, 0x3a, 0x99, 0x4c, 0x9f, 0x4e, 0xd0, 0x02, 0x67, 0x98, 0xe7, 0x70, 0x91, 0x89, 0x42, 0x38,
-	0x0f, 0x4d, 0x04, 0xae, 0x23, 0xb0, 0x89, 0x40, 0x13, 0x81, 0x3a, 0x72, 0xff, 0x36, 0x15, 0x54,
-	0xe8, 0x00, 0x52, 0x4f, 0x26, 0xeb, 0xff, 0xb6, 0xc1, 0xf0, 0xad, 0x2e, 0x73, 0x4a, 0xb0, 0xcd,
-	0x45, 0xca, 0x8e, 0x49, 0x16, 0x99, 0xfa, 0x1d, 0x6b, 0xd7, 0x1a, 0x6f, 0x3e, 0xde, 0x87, 0x17,
-	0xe9, 0x87, 0x87, 0x26, 0x6b, 0xca, 0x82, 0x07, 0xa7, 0x95, 0x37, 0x58, 0x55, 0xde, 0x9d, 0x12,
-	0xf3, 0xe4, 0x99, 0xdf, 0x2f, 0xf6, 0xc3, 0x11, 0xef, 0xce, 0x76, 0x3e, 0x83, 0xcd, 0x79, 0x81,
-	0xe9, 0x9a, 0x6b, 0x6b, 0xee, 0xe4, 0x62, 0xdc, 0x83, 0x77, 0x98, 0x36, 0xd0, 0xb1, 0x82, 0xd6,
-	0x95, 0x07, 0xda, 0xb1, 0x55, 0xe5, 0x39, 0x46, 0xa1, 0x03, 0xf0, 0x43, 0xa0, 0xde, 0x1a, 0x38,
-	0x07, 0xdb, 0x1c, 0xcb, 0x28, 0x66, 0x22, 0x4a, 0x48, 0x4a, 0x8b, 0xa3, 0x9d, 0x8d, 0x5d, 0x6b,
-	0xbc, 0x15, 0xbc, 0x50, 0x6d, 0x3f, 0x2b, 0xef, 0x11, 0x65, 0xc5, 0xd1, 0xa7, 0x18, 0xce, 0x04,
-	0x47, 0x33, 0xa1, 0x0f, 0xc7, 0xfc, 0xec, 0xe5, 0xf3, 0x63, 0x54, 0x94, 0x0b, 0x92, 0xc3, 0x97,
-	0x69, 0xd1, 0x59, 0x6c, 0xaf, 0xcd, 0x0f, 0xb7, 0x38, 0x96, 0x01, 0x13, 0xaf, 0xcd, 0xeb, 0x57,
-	0x1b, 0x8c, 0x7a, 0x7b, 0xe5, 0x94, 0xc0, 0xe1, 0x2c, 0x8d, 0xd6, 0x7b, 0xd4, 0x48, 0x58, 0x5a,
-	0xe2, 0xd5, 0xa5, 0x25, 0xee, 0x35, 0x12, 0xe7, 0x1a, 0xfd, 0xf0, 0x26, 0x67, 0x69, 0x83, 0x36,
-	0x32, 0x1a, 0x8d, 0xe5, 0xdf, 0x68, 0xfb, 0x8a, 0xe8, 0x73, 0x8d, 0x0a, 0x8d, 0x65, 0x0f, 0xed,
-	0x7f, 0xb7, 0x41, 0xe7, 0x9c, 0x9c, 0x31, 0x18, 0x66, 0x84, 0x46, 0x44, 0xea, 0x85, 0x5f, 0x0f,
-	0x6e, 0xad, 0x2a, 0x6f, 0x64, 0xfa, 0xcc, 0xb8, 0x1f, 0x5e, 0xcb, 0x08, 0x7d, 0x2e, 0x9d, 0x2f,
-	0x16, 0xb8, 0xa1, 0x56, 0xa7, 0x0f, 0xb4, 0x67, 0xfc, 0xfe, 0x72, 0xc6, 0x75, 0xe5, 0x8d, 0x0e,
-	0x59, 0xaa, 0x24, 0x8c, 0xd3, 0xaa, 0xf2, 0xee, 0xb6, 0xbb, 0xd7, 0xe9, 0x57, 0x7f, 0x58, 0x96,
-	0x1e, 0x14, 0xeb, 0x89, 0xc6, 0x01, 0xcb, 0x9e, 0xc3, 0xc6, 0x7f, 0x3b, 0x60, 0xf9, 0x4f, 0x87,
-	0x7e, 0xbf, 0x72, 0xc0, 0xb2, 0x75, 0x08, 0xde, 0x9c, 0xd6, 0xae, 0x75, 0x56, 0xbb, 0xd6, 0xaf,
-	0xda, 0xb5, 0xbe, 0x2d, 0xdd, 0xc1, 0xd9, 0xd2, 0x1d, 0xfc, 0x58, 0xba, 0x83, 0x0f, 0x4f, 0x3a,
-	0x6c, 0xf3, 0x0d, 0xed, 0x25, 0x38, 0xce, 0x9b, 0x67, 0x24, 0xdb, 0xcb, 0xa5, 0x7b, 0xa9, 0xc4,
-	0x43, 0x7d, 0x25, 0xec, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xb0, 0x15, 0x76, 0x03, 0x83, 0x04,
-	0x00, 0x00,
-}
-
-func (m *Params) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Params) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.MaxBioLength.Size()
-		i -= size
-		if _, err := m.MaxBioLength.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintParams(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1a
-	{
-		size, err := m.DTagParams.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintParams(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	{
-		size, err := m.MonikerParams.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintParams(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *MonikerParams) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *MonikerParams) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MonikerParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.MaxMonikerLength.Size()
-		i -= size
-		if _, err := m.MaxMonikerLength.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintParams(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	{
-		size := m.MinMonikerLength.Size()
-		i -= size
-		if _, err := m.MinMonikerLength.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintParams(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *DTagParams) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *DTagParams) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DTagParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.MaxDTagLength.Size()
-		i -= size
-		if _, err := m.MaxDTagLength.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintParams(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1a
-	{
-		size := m.MinDTagLength.Size()
-		i -= size
-		if _, err := m.MinDTagLength.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintParams(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	if len(m.RegEx) > 0 {
-		i -= len(m.RegEx)
-		copy(dAtA[i:], m.RegEx)
-		i = encodeVarintParams(dAtA, i, uint64(len(m.RegEx)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintParams(dAtA []byte, offset int, v uint64) int {
-	offset -= sovParams(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *Params) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.MonikerParams.Size()
-	n += 1 + l + sovParams(uint64(l))
-	l = m.DTagParams.Size()
-	n += 1 + l + sovParams(uint64(l))
-	l = m.MaxBioLength.Size()
-	n += 1 + l + sovParams(uint64(l))
-	return n
-}
-
-func (m *MonikerParams) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.MinMonikerLength.Size()
-	n += 1 + l + sovParams(uint64(l))
-	l = m.MaxMonikerLength.Size()
-	n += 1 + l + sovParams(uint64(l))
-	return n
-}
-
-func (m *DTagParams) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.RegEx)
-	if l > 0 {
-		n += 1 + l + sovParams(uint64(l))
-	}
-	l = m.MinDTagLength.Size()
-	n += 1 + l + sovParams(uint64(l))
-	l = m.MaxDTagLength.Size()
-	n += 1 + l + sovParams(uint64(l))
-	return n
-}
-
-func sovParams(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozParams(x uint64) (n int) {
-	return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *Params) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowParams
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Params: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MonikerParams", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MonikerParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DTagParams", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.DTagParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxBioLength", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MaxBioLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipParams(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthParams
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *MonikerParams) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowParams
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: MonikerParams: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MonikerParams: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinMonikerLength", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MinMonikerLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxMonikerLength", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MaxMonikerLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipParams(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthParams
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *DTagParams) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowParams
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: DTagParams: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DTagParams: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegEx", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.RegEx = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinDTagLength", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MinDTagLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxDTagLength", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.MaxDTagLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipParams(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthParams
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipParams(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowParams
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthParams
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupParams
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthParams
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthParams        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowParams          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group")
-)
diff --git a/x/profiles/legacy/v0160/store.go b/x/profiles/legacy/v0160/store.go
deleted file mode 100644
index 29118a13..00000000
--- a/x/profiles/legacy/v0160/store.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package v0160
-
-import (
-	"github.com/cosmos/cosmos-sdk/codec"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	paramstypes "github.com/cosmos/cosmos-sdk/x/params/types"
-
-	"github.com/desmos-labs/desmos/x/profiles/types"
-)
-
-// DONTCOVER
-
-// MigrateParams migrates the given params subspace to the new types.Params
-// This is used because parameters are stored as JSON inside the chain, so when we change the Protobuf field names
-// we should also migrate that to the new names
-func MigrateParams(ctx sdk.Context, amino *codec.LegacyAmino, subspace paramstypes.Subspace) (types.Params, error) {
-	var monikerParams MonikerParams
-	bz := subspace.GetRaw(ctx, MonikerLenParamsKey)
-	err := amino.UnmarshalJSON(bz, &monikerParams)
-	if err != nil {
-		return types.Params{}, err
-	}
-
-	var dTagParams DTagParams
-	bz = subspace.GetRaw(ctx, DTagParamsKey)
-	err = amino.UnmarshalJSON(bz, &dTagParams)
-	if err != nil {
-		return types.Params{}, err
-	}
-
-	var maxBioLen sdk.Int
-	bz = subspace.GetRaw(ctx, MaxBioLenParamsKey)
-	err = amino.UnmarshalJSON(bz, &maxBioLen)
-	if err != nil {
-		return types.Params{}, err
-	}
-
-	return types.NewParams(
-		types.NewNicknameParams(
-			monikerParams.MinMonikerLength,
-			monikerParams.MaxMonikerLength,
-		),
-		types.NewDTagParams(
-			dTagParams.RegEx,
-			dTagParams.MinDTagLength,
-			dTagParams.MaxDTagLength,
-		),
-		maxBioLen,
-	), nil
-}
diff --git a/x/profiles/simulation/params.go b/x/profiles/simulation/params.go
index 095d63b5..cc433a65 100644
--- a/x/profiles/simulation/params.go
+++ b/x/profiles/simulation/params.go
@@ -19,14 +19,14 @@ func ParamChanges(r *rand.Rand) []simtypes.ParamChange {
 			func(r *rand.Rand) string {
 				params := RandomNicknameParams(r)
 				return fmt.Sprintf(`{"min_nickname_len":"%s","max_nickname_len":"%s"}`,
-					params.MinNicknameLength, params.MaxNicknameLength)
+					params.MinLength, params.MaxLength)
 			},
 		),
 		simulation.NewSimParamChange(types.ModuleName, string(types.DTagLenParamsKey),
 			func(r *rand.Rand) string {
 				params := RandomDTagParams(r)
 				return fmt.Sprintf(`{"min_dtag_len":"%s","max_dtag_len":"%s"}`,
-					params.MinDTagLength, params.MaxDTagLength)
+					params.MinLength, params.MaxLength)
 			},
 		),
 		simulation.NewSimParamChange(types.ModuleName, string(types.MaxBioLenParamsKey),
diff --git a/x/profiles/simulation/utils.go b/x/profiles/simulation/utils.go
index e9cf24be..129d84b2 100644
--- a/x/profiles/simulation/utils.go
+++ b/x/profiles/simulation/utils.go
@@ -153,8 +153,9 @@ func RandomDTagParams(r *rand.Rand) types.DTagParams {
 }
 
 // RandomBioParams return a random biography param
-func RandomBioParams(r *rand.Rand) sdk.Int {
-	return sdk.NewInt(int64(simtypes.RandIntBetween(r, 500, 1000)))
+func RandomBioParams(r *rand.Rand) types.BioParams {
+	randomMax := sdk.NewInt(int64(simtypes.RandIntBetween(r, 500, 1000)))
+	return types.NewBioParams(randomMax)
 }
 
 // RandomRelationship picks and returns a random relationships from an array
diff --git a/x/profiles/types/genesis.pb.go b/x/profiles/types/genesis.pb.go
index a58a9c6d..e75e8f3a 100644
--- a/x/profiles/types/genesis.pb.go
+++ b/x/profiles/types/genesis.pb.go
@@ -26,12 +26,12 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 // GenesisState defines the profiles module's genesis state.
 type GenesisState struct {
 	DTagTransferRequests []DTagTransferRequest `protobuf:"bytes,1,rep,name=dtag_transfer_requests,json=dtagTransferRequests,proto3" json:"dtag_transfer_requests" yaml:"dtag_transfer_requests"`
-	Relationships        []Relationship        `protobuf:"bytes,2,rep,name=relationships,proto3" json:"relationships" yaml:"users_relationships"`
-	Blocks               []UserBlock           `protobuf:"bytes,3,rep,name=blocks,proto3" json:"blocks" yaml:"users_blocks"`
+	Relationships        []Relationship        `protobuf:"bytes,2,rep,name=relationships,proto3" json:"relationships" yaml:"relationships"`
+	Blocks               []UserBlock           `protobuf:"bytes,3,rep,name=blocks,proto3" json:"blocks" yaml:"blocks"`
 	Params               Params                `protobuf:"bytes,4,opt,name=params,proto3" json:"params" yaml:"params"`
 	IBCPortID            string                `protobuf:"bytes,5,opt,name=ibc_port_id,json=ibcPortId,proto3" json:"ibc_port_id,omitempty" yaml:"ibc_port_id"`
-	ChainLinks           []ChainLink           `protobuf:"bytes,6,rep,name=chain_links,json=chainLinks,proto3" json:"chain_links"`
-	ApplicationLinks     []ApplicationLink     `protobuf:"bytes,7,rep,name=application_links,json=applicationLinks,proto3" json:"application_links"`
+	ChainLinks           []ChainLink           `protobuf:"bytes,6,rep,name=chain_links,json=chainLinks,proto3" json:"chain_links" yaml:"chain_links"`
+	ApplicationLinks     []ApplicationLink     `protobuf:"bytes,7,rep,name=application_links,json=applicationLinks,proto3" json:"application_links" yaml:"application_links"`
 }
 
 func (m *GenesisState) Reset()         { *m = GenesisState{} }
@@ -76,40 +76,40 @@ func init() {
 }
 
 var fileDescriptor_24f308c1ccf2d582 = []byte{
-	// 525 bytes of a gzipped FileDescriptorProto
+	// 528 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xc1, 0x6e, 0xd3, 0x30,
-	0x1c, 0xc6, 0x1b, 0xb6, 0x15, 0xd5, 0x65, 0x12, 0x84, 0x02, 0x51, 0x11, 0x49, 0x15, 0x34, 0xa9,
-	0x12, 0x23, 0x61, 0xe5, 0x36, 0x89, 0x03, 0xe9, 0x24, 0xa8, 0x84, 0xd0, 0x14, 0x86, 0x90, 0xe0,
-	0x50, 0x39, 0xa9, 0x97, 0x5a, 0x4d, 0x63, 0x63, 0xbb, 0x88, 0xbd, 0x01, 0x47, 0x1e, 0x01, 0x9e,
-	0x84, 0xeb, 0x8e, 0x3b, 0x72, 0x8a, 0x50, 0xfa, 0x06, 0x7d, 0x02, 0x94, 0xd8, 0x65, 0xe9, 0xb4,
-	0x28, 0xdc, 0x22, 0xe7, 0xf7, 0xfd, 0xbe, 0x7f, 0x1c, 0x1b, 0xec, 0x4d, 0x10, 0x9f, 0x13, 0xee,
-	0x52, 0x46, 0x4e, 0x71, 0x8c, 0xb8, 0xfb, 0xe5, 0x20, 0x40, 0x02, 0x1e, 0xb8, 0x11, 0x4a, 0x10,
-	0xc7, 0xdc, 0xa1, 0x8c, 0x08, 0xa2, 0x3f, 0x90, 0x98, 0xb3, 0xc6, 0x1c, 0x85, 0x75, 0x3b, 0x11,
-	0x89, 0x48, 0xc1, 0xb8, 0xf9, 0x93, 0xc4, 0xbb, 0x4f, 0xaa, 0xac, 0x73, 0x32, 0x41, 0x31, 0x1f,
-	0x53, 0xc8, 0xe0, 0x5c, 0xb9, 0xbb, 0xfb, 0x75, 0xb0, 0x5c, 0x57, 0xf4, 0xa0, 0x86, 0x66, 0x28,
-	0x86, 0x02, 0x93, 0x84, 0x4f, 0x31, 0xe5, 0xff, 0x99, 0x99, 0x08, 0x18, 0x8d, 0x19, 0xfa, 0xbc,
-	0x40, 0x5c, 0xac, 0x33, 0xcf, 0x6a, 0x32, 0xe1, 0x14, 0xe2, 0x64, 0x1c, 0xe3, 0x64, 0xb6, 0x4e,
-	0x38, 0x35, 0x09, 0x48, 0x69, 0x99, 0xb7, 0x7f, 0xed, 0x80, 0x5b, 0xaf, 0xe4, 0x2e, 0xbf, 0x13,
-	0x50, 0x20, 0xfd, 0xa7, 0x06, 0xee, 0x17, 0xa3, 0x08, 0x06, 0x13, 0x7e, 0x8a, 0xd8, 0xbf, 0x99,
-	0x0c, 0xad, 0xb7, 0xd5, 0x6f, 0x0f, 0xf6, 0x9d, 0x8a, 0xdf, 0xe0, 0x1c, 0x9d, 0xc0, 0xe8, 0x44,
-	0xa5, 0x7c, 0x19, 0xf2, 0x5e, 0x9c, 0xa7, 0x56, 0x23, 0x4b, 0xad, 0xce, 0x35, 0x2f, 0xf9, 0x2a,
-	0xb5, 0x1e, 0x9d, 0xc1, 0x79, 0x7c, 0x68, 0x5f, 0xdf, 0x68, 0xfb, 0x9d, 0xfc, 0xc5, 0xd5, 0x98,
-	0x4e, 0xc0, 0xee, 0xc6, 0x0e, 0x1b, 0x37, 0x8a, 0xc9, 0xf6, 0x2a, 0x27, 0xf3, 0x4b, 0xb4, 0x67,
-	0xe7, 0x23, 0xad, 0x52, 0xab, 0x2b, 0xab, 0x17, 0x1c, 0xb1, 0x2b, 0x7f, 0xcc, 0xf6, 0x37, 0xfd,
-	0xfa, 0x07, 0xd0, 0x0c, 0x62, 0x12, 0xce, 0xb8, 0xb1, 0x55, 0x34, 0xd9, 0x95, 0x4d, 0xef, 0x39,
-	0x62, 0x5e, 0x8e, 0x7a, 0x0f, 0x55, 0xcd, 0xdd, 0x72, 0x8d, 0xb4, 0xd8, 0xbe, 0xd2, 0xe9, 0x6f,
-	0x41, 0x53, 0x1e, 0x43, 0x63, 0xbb, 0xa7, 0xf5, 0xdb, 0x03, 0xab, 0x52, 0x7c, 0x5c, 0x60, 0xde,
-	0x3d, 0x65, 0xdd, 0x95, 0x56, 0x19, 0xb6, 0x7d, 0x65, 0xd1, 0x87, 0xa0, 0x8d, 0x83, 0x70, 0x4c,
-	0x09, 0x13, 0x63, 0x3c, 0x31, 0x76, 0x7a, 0x5a, 0xbf, 0xe5, 0x3d, 0xce, 0x52, 0xab, 0x35, 0xf2,
-	0x86, 0xc7, 0x84, 0x89, 0xd1, 0xd1, 0x2a, 0xb5, 0x74, 0x19, 0x2e, 0x91, 0xb6, 0xdf, 0xc2, 0x41,
-	0x58, 0x00, 0x13, 0x7d, 0x04, 0xda, 0xa5, 0x83, 0x65, 0x34, 0x6b, 0x3e, 0x79, 0x98, 0xb3, 0x6f,
-	0x70, 0x32, 0xf3, 0xb6, 0xf3, 0xe1, 0x7c, 0x10, 0xae, 0x17, 0xb8, 0xfe, 0x09, 0xdc, 0x81, 0x94,
-	0xc6, 0x38, 0x2c, 0x36, 0x53, 0x09, 0x6f, 0x16, 0xc2, 0x7e, 0xa5, 0xf0, 0xe5, 0x65, 0xa2, 0xa4,
-	0xbd, 0x0d, 0x37, 0x97, 0xf9, 0xe1, 0xf6, 0xb7, 0x1f, 0x56, 0xc3, 0x7b, 0x7d, 0x9e, 0x99, 0xda,
-	0x45, 0x66, 0x6a, 0x7f, 0x32, 0x53, 0xfb, 0xbe, 0x34, 0x1b, 0x17, 0x4b, 0xb3, 0xf1, 0x7b, 0x69,
-	0x36, 0x3e, 0x3a, 0x11, 0x16, 0xd3, 0x45, 0xe0, 0x84, 0x64, 0xee, 0xca, 0xae, 0xa7, 0x31, 0x0c,
-	0xb8, 0x7a, 0x76, 0xbf, 0x5e, 0x5e, 0x12, 0x71, 0x46, 0x11, 0x0f, 0x9a, 0xc5, 0x95, 0x78, 0xfe,
-	0x37, 0x00, 0x00, 0xff, 0xff, 0x2d, 0x8b, 0xfc, 0x9e, 0x8f, 0x04, 0x00, 0x00,
+	0x1c, 0xc6, 0x1b, 0xb6, 0x15, 0xd5, 0x65, 0x12, 0x44, 0x05, 0xa2, 0x0a, 0x92, 0xca, 0x68, 0x52,
+	0x25, 0x46, 0xc2, 0xca, 0x6d, 0x12, 0x07, 0xd2, 0x49, 0x30, 0x09, 0xa1, 0x11, 0xc6, 0x85, 0x4b,
+	0xe4, 0xa4, 0x5e, 0x6a, 0x35, 0x8d, 0x8d, 0xed, 0x01, 0x7b, 0x03, 0x8e, 0x3c, 0x02, 0xbc, 0xcd,
+	0x8e, 0x3b, 0x72, 0x8a, 0x50, 0x2b, 0x5e, 0xa0, 0x4f, 0x80, 0x6a, 0xbb, 0xac, 0x1d, 0x8b, 0xca,
+	0xcd, 0xaa, 0x7f, 0xbf, 0xef, 0xfb, 0xd7, 0xb1, 0xc1, 0xce, 0x00, 0x8b, 0x31, 0x15, 0x01, 0xe3,
+	0xf4, 0x84, 0xe4, 0x58, 0x04, 0x9f, 0xf6, 0x12, 0x2c, 0xd1, 0x5e, 0x90, 0xe1, 0x02, 0x0b, 0x22,
+	0x7c, 0xc6, 0xa9, 0xa4, 0xf6, 0x7d, 0x8d, 0xf9, 0x0b, 0xcc, 0x37, 0x58, 0xbb, 0x95, 0xd1, 0x8c,
+	0x2a, 0x26, 0x98, 0xaf, 0x34, 0xde, 0x7e, 0x5c, 0x95, 0x3a, 0xa6, 0x03, 0x9c, 0x8b, 0x98, 0x21,
+	0x8e, 0xc6, 0x26, 0xbb, 0xbd, 0xbb, 0x0e, 0xd6, 0xbf, 0x1b, 0xba, 0xb7, 0x86, 0xe6, 0x38, 0x47,
+	0x92, 0xd0, 0x42, 0x0c, 0x09, 0x13, 0xff, 0xe9, 0x0c, 0x24, 0xca, 0x62, 0x8e, 0x3f, 0x9e, 0x62,
+	0x21, 0x17, 0xce, 0xd3, 0x35, 0x4e, 0x3a, 0x44, 0xa4, 0x88, 0x73, 0x52, 0x8c, 0x16, 0x86, 0xbf,
+	0xc6, 0x40, 0x8c, 0x2d, 0xf3, 0xf0, 0xf7, 0x16, 0xb8, 0xf5, 0x52, 0x9f, 0xf2, 0x3b, 0x89, 0x24,
+	0xb6, 0x7f, 0x58, 0xe0, 0x9e, 0x1a, 0x45, 0x72, 0x54, 0x88, 0x13, 0xcc, 0xff, 0xce, 0xe4, 0x58,
+	0x9d, 0x8d, 0x6e, 0xb3, 0xb7, 0xeb, 0x57, 0x7c, 0x06, 0xff, 0xe0, 0x18, 0x65, 0xc7, 0xc6, 0x8a,
+	0xb4, 0x14, 0x3e, 0x3f, 0x2f, 0xbd, 0xda, 0xa4, 0xf4, 0x5a, 0xd7, 0x6c, 0x8a, 0x59, 0xe9, 0x3d,
+	0x3c, 0x43, 0xe3, 0x7c, 0x1f, 0x5e, 0xdf, 0x08, 0xa3, 0xd6, 0x7c, 0xe3, 0xaa, 0x66, 0x13, 0xb0,
+	0xbd, 0x72, 0xc2, 0xce, 0x0d, 0x35, 0xd9, 0x4e, 0xe5, 0x64, 0xd1, 0x12, 0x1d, 0x3e, 0x98, 0x8f,
+	0x34, 0x2b, 0xbd, 0x96, 0xae, 0x5e, 0x49, 0x82, 0xd1, 0x6a, 0xb2, 0xfd, 0x16, 0xd4, 0x93, 0x9c,
+	0xa6, 0x23, 0xe1, 0x6c, 0xa8, 0x0e, 0x58, 0xd9, 0xf1, 0x5e, 0x60, 0x1e, 0xce, 0xd1, 0xf0, 0xae,
+	0x29, 0xd8, 0xd6, 0x05, 0xda, 0x87, 0x91, 0x09, 0xb2, 0xdf, 0x80, 0xba, 0xbe, 0x7a, 0xce, 0x66,
+	0xc7, 0xea, 0x36, 0x7b, 0x5e, 0x65, 0xe4, 0x91, 0xc2, 0xae, 0xe6, 0x69, 0x19, 0x46, 0x26, 0xc5,
+	0xee, 0x83, 0x26, 0x49, 0xd2, 0x98, 0x51, 0x2e, 0x63, 0x32, 0x70, 0xb6, 0x3a, 0x56, 0xb7, 0x11,
+	0x3e, 0x9a, 0x94, 0x5e, 0xe3, 0x30, 0xec, 0x1f, 0x51, 0x2e, 0x0f, 0x0f, 0x66, 0xa5, 0x67, 0x6b,
+	0x79, 0x89, 0x84, 0x51, 0x83, 0x24, 0xa9, 0x02, 0x06, 0x76, 0x0c, 0x9a, 0x4b, 0x97, 0xc9, 0xa9,
+	0xaf, 0xf9, 0xb3, 0xfd, 0x39, 0xfb, 0x9a, 0x14, 0xa3, 0xb0, 0x6d, 0x86, 0x33, 0xf9, 0x4b, 0x21,
+	0x30, 0x02, 0xe9, 0x02, 0x13, 0xf6, 0x67, 0x70, 0x07, 0x31, 0x96, 0x93, 0x54, 0x1d, 0xae, 0xa9,
+	0xb9, 0xa9, 0x6a, 0xba, 0x95, 0x35, 0x2f, 0x2e, 0x0d, 0x55, 0xd6, 0x31, 0x65, 0x8e, 0x2e, 0xfb,
+	0x27, 0x10, 0x46, 0xb7, 0xd1, 0xaa, 0x22, 0xf6, 0x37, 0xbf, 0x7e, 0xf7, 0x6a, 0xe1, 0xab, 0xf3,
+	0x89, 0x6b, 0x5d, 0x4c, 0x5c, 0xeb, 0xd7, 0xc4, 0xb5, 0xbe, 0x4d, 0xdd, 0xda, 0xc5, 0xd4, 0xad,
+	0xfd, 0x9c, 0xba, 0xb5, 0x0f, 0x7e, 0x46, 0xe4, 0xf0, 0x34, 0xf1, 0x53, 0x3a, 0x0e, 0xf4, 0x1c,
+	0x4f, 0x72, 0x94, 0x08, 0xb3, 0x0e, 0xbe, 0x5c, 0x3e, 0x25, 0x79, 0xc6, 0xb0, 0x48, 0xea, 0xea,
+	0xe1, 0x3c, 0xfb, 0x13, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x23, 0xa4, 0x8c, 0xb5, 0x04, 0x00, 0x00,
 }
 
 func (m *GenesisState) Marshal() (dAtA []byte, err error) {
diff --git a/x/profiles/types/models_params.go b/x/profiles/types/models_params.go
index 417bfdf2..bb7364d0 100644
--- a/x/profiles/types/models_params.go
+++ b/x/profiles/types/models_params.go
@@ -40,20 +40,20 @@ func ParamKeyTable() paramstypes.KeyTable {
 }
 
 // NewParams creates a new ProfileParams obj
-func NewParams(nicknameParams NicknameParams, dTagParams DTagParams, maxBioLen sdk.Int) Params {
+func NewParams(nickname NicknameParams, dTag DTagParams, bio BioParams) Params {
 	return Params{
-		NicknameParams: nicknameParams,
-		DTagParams:     dTagParams,
-		MaxBioLength:   maxBioLen,
+		Nickname: nickname,
+		DTag:     dTag,
+		Bio:      bio,
 	}
 }
 
 // DefaultParams return default paramsModule
 func DefaultParams() Params {
 	return Params{
-		NicknameParams: DefaultNicknameParams(),
-		DTagParams:     DefaultDTagParams(),
-		MaxBioLength:   DefaultMaxBioLength,
+		Nickname: DefaultNicknameParams(),
+		DTag:     DefaultDTagParams(),
+		Bio:      DefaultBioParams(),
 	}
 }
 
@@ -61,23 +61,23 @@ func DefaultParams() Params {
 // of profile module's parameters.
 func (params *Params) ParamSetPairs() paramstypes.ParamSetPairs {
 	return paramstypes.ParamSetPairs{
-		paramstypes.NewParamSetPair(NicknameLenParamsKey, &params.NicknameParams, ValidateNicknameParams),
-		paramstypes.NewParamSetPair(DTagLenParamsKey, &params.DTagParams, ValidateDTagParams),
-		paramstypes.NewParamSetPair(MaxBioLenParamsKey, &params.MaxBioLength, ValidateBioParams),
+		paramstypes.NewParamSetPair(NicknameLenParamsKey, &params.Nickname, ValidateNicknameParams),
+		paramstypes.NewParamSetPair(DTagLenParamsKey, &params.DTag, ValidateDTagParams),
+		paramstypes.NewParamSetPair(MaxBioLenParamsKey, &params.Bio, ValidateBioParams),
 	}
 }
 
 // Validate perform basic checks on all parameters to ensure they are correct
 func (params Params) Validate() error {
-	if err := ValidateNicknameParams(params.NicknameParams); err != nil {
+	if err := ValidateNicknameParams(params.Nickname); err != nil {
 		return err
 	}
 
-	if err := ValidateDTagParams(params.DTagParams); err != nil {
+	if err := ValidateDTagParams(params.DTag); err != nil {
 		return err
 	}
 
-	return ValidateBioParams(params.MaxBioLength)
+	return ValidateBioParams(params.Bio)
 }
 
 // ___________________________________________________________________________________________________________________
@@ -85,8 +85,8 @@ func (params Params) Validate() error {
 // NewNicknameParams creates a new NicknameParams obj
 func NewNicknameParams(minLen, maxLen sdk.Int) NicknameParams {
 	return NicknameParams{
-		MinNicknameLength: minLen,
-		MaxNicknameLength: maxLen,
+		MinLength: minLen,
+		MaxLength: maxLen,
 	}
 }
 
@@ -104,13 +104,13 @@ func ValidateNicknameParams(i interface{}) error {
 		return fmt.Errorf("invalid parameters type: %s", i)
 	}
 
-	minLength := params.MinNicknameLength
+	minLength := params.MinLength
 	if minLength.IsNil() || minLength.LT(DefaultMinNicknameLength) {
 		return fmt.Errorf("invalid minimum nickname length param: %s", minLength)
 	}
 
 	// TODO make sense to cap this? I've done this thinking "what's the sense of having names higher that 1000 chars?"
-	maxLength := params.MaxNicknameLength
+	maxLength := params.MaxLength
 	if maxLength.IsNil() || maxLength.IsNegative() || maxLength.GT(DefaultMaxNicknameLength) {
 		return fmt.Errorf("invalid max nickname length param: %s", maxLength)
 	}
@@ -123,9 +123,9 @@ func ValidateNicknameParams(i interface{}) error {
 // NewDTagParams creates a new DTagParams obj
 func NewDTagParams(regEx string, minLen, maxLen sdk.Int) DTagParams {
 	return DTagParams{
-		RegEx:         regEx,
-		MinDTagLength: minLen,
-		MaxDTagLength: maxLen,
+		RegEx:     regEx,
+		MinLength: minLen,
+		MaxLength: maxLen,
 	}
 }
 
@@ -148,12 +148,12 @@ func ValidateDTagParams(i interface{}) error {
 		return fmt.Errorf("empty dTag regEx param")
 	}
 
-	if params.MinDTagLength.IsNegative() || params.MinDTagLength.LT(DefaultMinDTagLength) {
-		return fmt.Errorf("invalid minimum dTag length param: %s", params.MinDTagLength)
+	if params.MinLength.IsNegative() || params.MinLength.LT(DefaultMinDTagLength) {
+		return fmt.Errorf("invalid minimum dTag length param: %s", params.MinLength)
 	}
 
-	if params.MaxDTagLength.IsNegative() {
-		return fmt.Errorf("invalid max dTag length param: %s", params.MaxDTagLength)
+	if params.MaxLength.IsNegative() {
+		return fmt.Errorf("invalid max dTag length param: %s", params.MaxLength)
 	}
 
 	return nil
@@ -161,14 +161,26 @@ func ValidateDTagParams(i interface{}) error {
 
 // ___________________________________________________________________________________________________________________
 
+// NewBioParams creates a new BioParams obj
+func NewBioParams(maxLength sdk.Int) BioParams {
+	return BioParams{
+		MaxLength: maxLength,
+	}
+}
+
+// DefaultBioParams returns default params module
+func DefaultBioParams() BioParams {
+	return NewBioParams(DefaultMaxBioLength)
+}
+
 func ValidateBioParams(i interface{}) error {
-	bioLen, isBioLenParams := i.(sdk.Int)
-	if !isBioLenParams {
+	bioParams, isBioParams := i.(BioParams)
+	if !isBioParams {
 		return fmt.Errorf("invalid parameters type: %s", i)
 	}
 
-	if bioLen.IsNegative() {
-		return fmt.Errorf("invalid max bio length param: %s", bioLen)
+	if bioParams.MaxLength.IsNegative() {
+		return fmt.Errorf("invalid max bio length param: %s", bioParams.MaxLength)
 	}
 
 	return nil
diff --git a/x/profiles/types/models_params.pb.go b/x/profiles/types/models_params.pb.go
index e11ababd..410c7a12 100644
--- a/x/profiles/types/models_params.pb.go
+++ b/x/profiles/types/models_params.pb.go
@@ -26,9 +26,9 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 // Params contains the parameters for the profiles module
 type Params struct {
-	NicknameParams NicknameParams                         `protobuf:"bytes,1,opt,name=nickname_params,json=nicknameParams,proto3" json:"nickname_params" yaml:"nickname_params"`
-	DTagParams     DTagParams                             `protobuf:"bytes,2,opt,name=dtag_params,json=dtagParams,proto3" json:"dtag_params" yaml:"dtag_params"`
-	MaxBioLength   github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=max_bio_length,json=maxBioLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_bio_length" yaml:"max_bio_length"`
+	Nickname NicknameParams `protobuf:"bytes,1,opt,name=nickname,proto3" json:"nickname" yaml:"nickname"`
+	DTag     DTagParams     `protobuf:"bytes,2,opt,name=dtag,proto3" json:"dtag" yaml:"dtag"`
+	Bio      BioParams      `protobuf:"bytes,3,opt,name=bio,proto3" json:"bio" yaml:"bio"`
 }
 
 func (m *Params) Reset()         { *m = Params{} }
@@ -66,8 +66,8 @@ var xxx_messageInfo_Params proto.InternalMessageInfo
 
 // NicknameParams defines the parameters related to the profiles nicknames
 type NicknameParams struct {
-	MinNicknameLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=min_nickname_length,json=minNicknameLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_nickname_length" yaml:"min_nickname_length"`
-	MaxNicknameLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=max_nickname_length,json=maxNicknameLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_nickname_length" yaml:"max_nickname_length"`
+	MinLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=min_length,json=minLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_length" yaml:"min_length"`
+	MaxLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=max_length,json=maxLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_length" yaml:"max_length"`
 }
 
 func (m *NicknameParams) Reset()         { *m = NicknameParams{} }
@@ -105,9 +105,9 @@ var xxx_messageInfo_NicknameParams proto.InternalMessageInfo
 
 // DTagParams defines the parameters related to profile DTags
 type DTagParams struct {
-	RegEx         string                                 `protobuf:"bytes,1,opt,name=reg_ex,json=regEx,proto3" json:"reg_ex,omitempty" yaml:"reg_ex"`
-	MinDTagLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=min_dtag_length,json=minDtagLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_dtag_length" yaml:"min_dtag_length"`
-	MaxDTagLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=max_dtag_length,json=maxDtagLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_dtag_length" yaml:"max_dtag_length"`
+	RegEx     string                                 `protobuf:"bytes,1,opt,name=reg_ex,json=regEx,proto3" json:"reg_ex,omitempty" yaml:"reg_ex"`
+	MinLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=min_length,json=minLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_length" yaml:"min_length"`
+	MaxLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=max_length,json=maxLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_length" yaml:"max_length"`
 }
 
 func (m *DTagParams) Reset()         { *m = DTagParams{} }
@@ -143,10 +143,48 @@ func (m *DTagParams) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_DTagParams proto.InternalMessageInfo
 
+type BioParams struct {
+	MaxLength github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=max_length,json=maxLength,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_length" yaml:"max_length"`
+}
+
+func (m *BioParams) Reset()         { *m = BioParams{} }
+func (m *BioParams) String() string { return proto.CompactTextString(m) }
+func (*BioParams) ProtoMessage()    {}
+func (*BioParams) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a621950d5c07fbad, []int{3}
+}
+func (m *BioParams) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BioParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BioParams.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *BioParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BioParams.Merge(m, src)
+}
+func (m *BioParams) XXX_Size() int {
+	return m.Size()
+}
+func (m *BioParams) XXX_DiscardUnknown() {
+	xxx_messageInfo_BioParams.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BioParams proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*Params)(nil), "desmos.profiles.v1beta1.Params")
 	proto.RegisterType((*NicknameParams)(nil), "desmos.profiles.v1beta1.NicknameParams")
 	proto.RegisterType((*DTagParams)(nil), "desmos.profiles.v1beta1.DTagParams")
+	proto.RegisterType((*BioParams)(nil), "desmos.profiles.v1beta1.BioParams")
 }
 
 func init() {
@@ -154,39 +192,36 @@ func init() {
 }
 
 var fileDescriptor_a621950d5c07fbad = []byte{
-	// 499 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xcf, 0x6e, 0xd3, 0x30,
-	0x1c, 0xc7, 0x93, 0x0c, 0x2a, 0xe1, 0xad, 0x9d, 0x16, 0xfe, 0x4d, 0x3b, 0xc4, 0x93, 0x91, 0xa0,
-	0x12, 0x5a, 0xa2, 0xc1, 0x6d, 0xc7, 0x68, 0x08, 0x90, 0x06, 0x42, 0x11, 0x17, 0xb8, 0x44, 0x4e,
-	0x6b, 0x32, 0x6b, 0xb1, 0x1d, 0x25, 0x01, 0x79, 0x12, 0x17, 0x6e, 0x1c, 0x11, 0x4f, 0xc0, 0xc3,
-	0x70, 0xd8, 0x71, 0x47, 0xc4, 0x21, 0xa0, 0xf4, 0x0d, 0xfa, 0x04, 0x28, 0xb6, 0x4b, 0x9b, 0x95,
-	0x1d, 0xca, 0x4e, 0x8d, 0xad, 0x6f, 0xbf, 0x9f, 0x4f, 0x7f, 0x6e, 0x0c, 0x1e, 0x8e, 0x49, 0xc9,
-	0x44, 0x19, 0xe4, 0x85, 0x78, 0x47, 0x33, 0x52, 0x06, 0x1f, 0xf6, 0x13, 0x52, 0xe1, 0xfd, 0x80,
-	0x89, 0x31, 0xc9, 0xca, 0x38, 0xc7, 0x05, 0x66, 0xa5, 0x9f, 0x17, 0xa2, 0x12, 0xee, 0x5d, 0x1d,
-	0xf6, 0x67, 0x61, 0xdf, 0x84, 0x77, 0x6e, 0xa5, 0x22, 0x15, 0x2a, 0x13, 0xb4, 0x4f, 0x3a, 0x8e,
-	0x7e, 0x39, 0xa0, 0xf7, 0x4a, 0x7d, 0xdf, 0xcd, 0xc1, 0x26, 0xa7, 0xa3, 0x13, 0x8e, 0x19, 0x31,
-	0x95, 0xdb, 0xf6, 0xae, 0x3d, 0x5c, 0x7f, 0xf4, 0xc0, 0xbf, 0xa4, 0xd3, 0x7f, 0x69, 0xf2, 0xba,
-	0x21, 0xf4, 0xce, 0x6a, 0x68, 0x4d, 0x6b, 0x78, 0xe7, 0x14, 0xb3, 0xec, 0x00, 0x5d, 0x68, 0x43,
-	0xd1, 0x80, 0x77, 0xf2, 0x2e, 0x07, 0xeb, 0xe3, 0x0a, 0xa7, 0x33, 0x9a, 0xa3, 0x68, 0xf7, 0x2e,
-	0xa5, 0x1d, 0xbe, 0xc6, 0xa9, 0x21, 0x0d, 0x5b, 0x52, 0x53, 0x43, 0x30, 0xdf, 0x9b, 0xd6, 0xd0,
-	0xd5, 0xdc, 0x85, 0x4e, 0x14, 0x81, 0x76, 0x65, 0x78, 0x0c, 0x0c, 0x18, 0x96, 0x71, 0x42, 0x45,
-	0x9c, 0x11, 0x9e, 0x56, 0xc7, 0xdb, 0x6b, 0xbb, 0xf6, 0x70, 0x23, 0x7c, 0xda, 0xb6, 0xfd, 0xac,
-	0xe1, 0xfd, 0x94, 0x56, 0xc7, 0xef, 0x13, 0x7f, 0x24, 0x58, 0x30, 0x12, 0x6a, 0xe6, 0xfa, 0x63,
-	0xaf, 0x1c, 0x9f, 0x04, 0xd5, 0x69, 0x4e, 0x4a, 0xff, 0x39, 0xaf, 0xa6, 0x35, 0xbc, 0xad, 0x49,
-	0xdd, 0x36, 0x14, 0x6d, 0x30, 0x2c, 0x43, 0x2a, 0x8e, 0xd4, 0xf2, 0xe0, 0xda, 0xe7, 0x6f, 0xd0,
-	0x42, 0x5f, 0x1d, 0x30, 0xe8, 0xce, 0xc9, 0xfd, 0x08, 0x6e, 0x32, 0xca, 0xe3, 0xbf, 0xf3, 0x31,
-	0x32, 0xb6, 0x92, 0x39, 0x5a, 0x59, 0x66, 0xc7, 0xc8, 0x2c, 0x57, 0xa2, 0x68, 0x8b, 0x51, 0x3e,
-	0xa3, 0x6b, 0x2d, 0x45, 0xc7, 0x72, 0x89, 0xee, 0x5c, 0x91, 0xbe, 0x5c, 0xd9, 0xd2, 0xb1, 0xec,
-	0xd2, 0xcd, 0x50, 0xbe, 0x3b, 0x60, 0xe1, 0xe8, 0xdc, 0x21, 0xe8, 0x15, 0x24, 0x8d, 0x89, 0x54,
-	0x33, 0xb8, 0x11, 0x6e, 0x4d, 0x6b, 0xd8, 0xd7, 0xbd, 0x7a, 0x1f, 0x45, 0xd7, 0x0b, 0x92, 0x3e,
-	0x91, 0xee, 0x27, 0x1b, 0x6c, 0xb6, 0x3f, 0x54, 0x9d, 0x71, 0xc7, 0xfc, 0xcd, 0x6a, 0xe6, 0x4d,
-	0x0d, 0xfb, 0x2f, 0x28, 0x6f, 0x25, 0xb4, 0xd9, 0xfc, 0x7f, 0x7b, 0xa1, 0x1f, 0x45, 0x7d, 0x46,
-	0xf9, 0x61, 0x35, 0x0b, 0x6a, 0x07, 0x2c, 0x3b, 0x0e, 0x6b, 0xff, 0xed, 0x80, 0xe5, 0x3f, 0x1d,
-	0xba, 0xfd, 0xad, 0x03, 0x96, 0x73, 0x07, 0x3d, 0xc6, 0xf0, 0xd9, 0x59, 0xe3, 0xd9, 0xe7, 0x8d,
-	0x67, 0xff, 0x6e, 0x3c, 0xfb, 0xcb, 0xc4, 0xb3, 0xce, 0x27, 0x9e, 0xf5, 0x63, 0xe2, 0x59, 0x6f,
-	0xfd, 0x05, 0x03, 0xfd, 0x3e, 0xed, 0x65, 0x38, 0x29, 0xcd, 0x73, 0x20, 0xe7, 0x97, 0x89, 0xb2,
-	0x49, 0x7a, 0xea, 0x3a, 0x78, 0xfc, 0x27, 0x00, 0x00, 0xff, 0xff, 0xeb, 0xa6, 0x80, 0x7e, 0x6c,
-	0x04, 0x00, 0x00,
+	// 464 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x94, 0x4f, 0x8b, 0xd4, 0x30,
+	0x18, 0xc6, 0xdb, 0x99, 0x71, 0x70, 0xb2, 0xfe, 0x61, 0x83, 0xb0, 0x83, 0x42, 0x23, 0x11, 0x74,
+	0x41, 0x36, 0x65, 0xf5, 0xb6, 0xc7, 0xaa, 0xb0, 0x82, 0xca, 0x52, 0xf6, 0x24, 0xc2, 0x90, 0xce,
+	0xc4, 0x6c, 0xd8, 0xa6, 0x19, 0x9a, 0xae, 0x74, 0xbf, 0x81, 0x07, 0x0f, 0x7e, 0x02, 0xf1, 0xe3,
+	0xec, 0x71, 0x8f, 0xe2, 0x21, 0x48, 0xe7, 0x1b, 0xf4, 0x13, 0x48, 0x93, 0x76, 0xc6, 0x11, 0x06,
+	0xff, 0xe1, 0x69, 0x5e, 0xc2, 0x93, 0xdf, 0xf3, 0xbe, 0xcf, 0x9b, 0x29, 0x78, 0x38, 0x63, 0x5a,
+	0x2a, 0x1d, 0xce, 0x73, 0xf5, 0x56, 0xa4, 0x4c, 0x87, 0xef, 0xf6, 0x13, 0x56, 0xd0, 0xfd, 0x50,
+	0xaa, 0x19, 0x4b, 0xf5, 0x64, 0x4e, 0x73, 0x2a, 0x35, 0x99, 0xe7, 0xaa, 0x50, 0x70, 0xc7, 0x89,
+	0x49, 0x27, 0x26, 0xad, 0xf8, 0xf6, 0x2d, 0xae, 0xb8, 0xb2, 0x9a, 0xb0, 0xa9, 0x9c, 0x1c, 0x7f,
+	0xe8, 0x81, 0xe1, 0x91, 0xbd, 0x0f, 0xdf, 0x80, 0xab, 0x99, 0x98, 0x9e, 0x66, 0x54, 0xb2, 0xb1,
+	0x7f, 0xd7, 0xdf, 0xdd, 0x7a, 0xf4, 0x80, 0x6c, 0x80, 0x91, 0x57, 0xad, 0xd0, 0x5d, 0x8d, 0x76,
+	0x2e, 0x0c, 0xf2, 0x6a, 0x83, 0x6e, 0x9e, 0x53, 0x99, 0x1e, 0xe0, 0x0e, 0x83, 0xe3, 0x25, 0x11,
+	0x1e, 0x83, 0xc1, 0xac, 0xa0, 0x7c, 0xdc, 0xb3, 0xe4, 0x7b, 0x1b, 0xc9, 0x4f, 0x8f, 0x29, 0x6f,
+	0xa9, 0x77, 0x1a, 0x6a, 0x65, 0xd0, 0xa0, 0x39, 0xab, 0x0d, 0xda, 0x72, 0xf4, 0x06, 0x83, 0x63,
+	0x4b, 0x83, 0x87, 0xa0, 0x9f, 0x08, 0x35, 0xee, 0x5b, 0x28, 0xde, 0x08, 0x8d, 0x84, 0x6a, 0x99,
+	0xb0, 0xed, 0x14, 0x38, 0x56, 0x22, 0x14, 0x8e, 0x1b, 0xc4, 0xc1, 0xe0, 0xfd, 0x67, 0xe4, 0x61,
+	0xe3, 0x83, 0x1b, 0xeb, 0xb3, 0xc1, 0x04, 0x00, 0x29, 0xb2, 0x49, 0xca, 0x32, 0x5e, 0x9c, 0xd8,
+	0x60, 0xae, 0x45, 0x4f, 0x1a, 0xca, 0x57, 0x83, 0xee, 0x73, 0x51, 0x9c, 0x9c, 0x25, 0x64, 0xaa,
+	0x64, 0x38, 0x55, 0x76, 0x49, 0xee, 0x67, 0x4f, 0xcf, 0x4e, 0xc3, 0xe2, 0x7c, 0xce, 0x34, 0x79,
+	0x9e, 0x15, 0xb5, 0x41, 0xdb, 0xce, 0x6f, 0x45, 0xc2, 0xf1, 0x48, 0x8a, 0xec, 0x85, 0xad, 0xad,
+	0x07, 0x2d, 0x3b, 0x8f, 0xde, 0x3f, 0x7a, 0x2c, 0x49, 0x8d, 0x07, 0x2d, 0x9d, 0x47, 0x3b, 0xe0,
+	0xa7, 0x1e, 0x00, 0xab, 0x88, 0xe1, 0x2e, 0x18, 0xe6, 0x8c, 0x4f, 0x58, 0x69, 0x07, 0x1b, 0x45,
+	0xdb, 0xb5, 0x41, 0xd7, 0x1d, 0xc6, 0x9d, 0xe3, 0xf8, 0x4a, 0xce, 0xf8, 0xb3, 0x12, 0xaa, 0xb5,
+	0x18, 0x5c, 0x8b, 0x47, 0x7f, 0xd6, 0x62, 0x65, 0xd0, 0xe8, 0x65, 0x37, 0xf3, 0x2f, 0x33, 0x51,
+	0x6b, 0x99, 0xf4, 0xff, 0xda, 0xb0, 0x0b, 0xe0, 0x37, 0x03, 0x3a, 0x03, 0xa3, 0xe5, 0x6b, 0xf9,
+	0x69, 0x2f, 0xfd, 0xff, 0xb7, 0x97, 0xe8, 0xf0, 0xa2, 0x0a, 0xfc, 0xcb, 0x2a, 0xf0, 0xbf, 0x55,
+	0x81, 0xff, 0x71, 0x11, 0x78, 0x97, 0x8b, 0xc0, 0xfb, 0xb2, 0x08, 0xbc, 0xd7, 0xe4, 0x07, 0x1f,
+	0xf7, 0xbe, 0xf7, 0x52, 0x9a, 0xe8, 0xb6, 0x0e, 0xcb, 0xd5, 0x67, 0xc1, 0x7a, 0x26, 0x43, 0xfb,
+	0xc7, 0x7e, 0xfc, 0x3d, 0x00, 0x00, 0xff, 0xff, 0xe6, 0xc6, 0x34, 0x1c, 0x36, 0x04, 0x00, 0x00,
 }
 
 func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -210,17 +245,17 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	{
-		size := m.MaxBioLength.Size()
-		i -= size
-		if _, err := m.MaxBioLength.MarshalTo(dAtA[i:]); err != nil {
+		size, err := m.Bio.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
 			return 0, err
 		}
+		i -= size
 		i = encodeVarintModelsParams(dAtA, i, uint64(size))
 	}
 	i--
 	dAtA[i] = 0x1a
 	{
-		size, err := m.DTagParams.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.DTag.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -230,7 +265,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x12
 	{
-		size, err := m.NicknameParams.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.Nickname.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -263,9 +298,9 @@ func (m *NicknameParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	{
-		size := m.MaxNicknameLength.Size()
+		size := m.MaxLength.Size()
 		i -= size
-		if _, err := m.MaxNicknameLength.MarshalTo(dAtA[i:]); err != nil {
+		if _, err := m.MaxLength.MarshalTo(dAtA[i:]); err != nil {
 			return 0, err
 		}
 		i = encodeVarintModelsParams(dAtA, i, uint64(size))
@@ -273,9 +308,9 @@ func (m *NicknameParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x12
 	{
-		size := m.MinNicknameLength.Size()
+		size := m.MinLength.Size()
 		i -= size
-		if _, err := m.MinNicknameLength.MarshalTo(dAtA[i:]); err != nil {
+		if _, err := m.MinLength.MarshalTo(dAtA[i:]); err != nil {
 			return 0, err
 		}
 		i = encodeVarintModelsParams(dAtA, i, uint64(size))
@@ -306,9 +341,9 @@ func (m *DTagParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	{
-		size := m.MaxDTagLength.Size()
+		size := m.MaxLength.Size()
 		i -= size
-		if _, err := m.MaxDTagLength.MarshalTo(dAtA[i:]); err != nil {
+		if _, err := m.MaxLength.MarshalTo(dAtA[i:]); err != nil {
 			return 0, err
 		}
 		i = encodeVarintModelsParams(dAtA, i, uint64(size))
@@ -316,9 +351,9 @@ func (m *DTagParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x1a
 	{
-		size := m.MinDTagLength.Size()
+		size := m.MinLength.Size()
 		i -= size
-		if _, err := m.MinDTagLength.MarshalTo(dAtA[i:]); err != nil {
+		if _, err := m.MinLength.MarshalTo(dAtA[i:]); err != nil {
 			return 0, err
 		}
 		i = encodeVarintModelsParams(dAtA, i, uint64(size))
@@ -335,6 +370,39 @@ func (m *DTagParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *BioParams) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BioParams) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BioParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.MaxLength.Size()
+		i -= size
+		if _, err := m.MaxLength.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintModelsParams(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintModelsParams(dAtA []byte, offset int, v uint64) int {
 	offset -= sovModelsParams(v)
 	base := offset
@@ -352,11 +420,11 @@ func (m *Params) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = m.NicknameParams.Size()
+	l = m.Nickname.Size()
 	n += 1 + l + sovModelsParams(uint64(l))
-	l = m.DTagParams.Size()
+	l = m.DTag.Size()
 	n += 1 + l + sovModelsParams(uint64(l))
-	l = m.MaxBioLength.Size()
+	l = m.Bio.Size()
 	n += 1 + l + sovModelsParams(uint64(l))
 	return n
 }
@@ -367,9 +435,9 @@ func (m *NicknameParams) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = m.MinNicknameLength.Size()
+	l = m.MinLength.Size()
 	n += 1 + l + sovModelsParams(uint64(l))
-	l = m.MaxNicknameLength.Size()
+	l = m.MaxLength.Size()
 	n += 1 + l + sovModelsParams(uint64(l))
 	return n
 }
@@ -384,9 +452,20 @@ func (m *DTagParams) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovModelsParams(uint64(l))
 	}
-	l = m.MinDTagLength.Size()
+	l = m.MinLength.Size()
 	n += 1 + l + sovModelsParams(uint64(l))
-	l = m.MaxDTagLength.Size()
+	l = m.MaxLength.Size()
+	n += 1 + l + sovModelsParams(uint64(l))
+	return n
+}
+
+func (m *BioParams) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.MaxLength.Size()
 	n += 1 + l + sovModelsParams(uint64(l))
 	return n
 }
@@ -428,7 +507,7 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NicknameParams", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Nickname", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -455,13 +534,13 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.NicknameParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Nickname.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DTagParams", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field DTag", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -488,15 +567,15 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.DTagParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.DTag.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxBioLength", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Bio", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowModelsParams
@@ -506,22 +585,22 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthModelsParams
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthModelsParams
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.MaxBioLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Bio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -577,7 +656,7 @@ func (m *NicknameParams) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinNicknameLength", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MinLength", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -604,13 +683,13 @@ func (m *NicknameParams) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.MinNicknameLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.MinLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxNicknameLength", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxLength", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -637,7 +716,7 @@ func (m *NicknameParams) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.MaxNicknameLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.MaxLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -725,7 +804,7 @@ func (m *DTagParams) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinDTagLength", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MinLength", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -752,13 +831,96 @@ func (m *DTagParams) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.MinDTagLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.MinLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxDTagLength", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxLength", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowModelsParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthModelsParams
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthModelsParams
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.MaxLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipModelsParams(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthModelsParams
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *BioParams) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowModelsParams
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: BioParams: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: BioParams: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxLength", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -785,7 +947,7 @@ func (m *DTagParams) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.MaxDTagLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.MaxLength.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/x/profiles/types/msgs_dtag_requests.pb.go b/x/profiles/types/msgs_dtag_requests.pb.go
index 908facdc..f1819ce4 100644
--- a/x/profiles/types/msgs_dtag_requests.pb.go
+++ b/x/profiles/types/msgs_dtag_requests.pb.go
@@ -149,8 +149,8 @@ func (m *MsgCancelDTagTransferRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgCancelDTagTransferRequest proto.InternalMessageInfo
 
-// MsgCancelDTagTransferRequestResponse represents the Msg/CancelDTagTransferRequest
-// response type.
+// MsgCancelDTagTransferRequestResponse represents the
+// Msg/CancelDTagTransferRequest response type.
 type MsgCancelDTagTransferRequestResponse struct {
 }
 
@@ -232,8 +232,8 @@ func (m *MsgAcceptDTagTransferRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgAcceptDTagTransferRequest proto.InternalMessageInfo
 
-// MsgAcceptDTagTransferRequestResponse defines the Msg/AcceptDTagTransferRequest
-// response.
+// MsgAcceptDTagTransferRequestResponse defines the
+// Msg/AcceptDTagTransferRequest response.
 type MsgAcceptDTagTransferRequestResponse struct {
 }
 
@@ -312,8 +312,8 @@ func (m *MsgRefuseDTagTransferRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgRefuseDTagTransferRequest proto.InternalMessageInfo
 
-// MsgRefuseDTagTransferRequestResponse defines the Msg/RefuseDTagTransferRequest
-// response.
+// MsgRefuseDTagTransferRequestResponse defines the
+// Msg/RefuseDTagTransferRequest response.
 type MsgRefuseDTagTransferRequestResponse struct {
 }
 
diff --git a/x/staging/posts/types/msgs.pb.go b/x/staging/posts/types/msgs.pb.go
index 778ffe4d..201ff717 100644
--- a/x/staging/posts/types/msgs.pb.go
+++ b/x/staging/posts/types/msgs.pb.go
@@ -2910,7 +2910,7 @@ func (m *MsgAnswerPoll) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ProvidedAnswers", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Answers", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
diff --git a/x/staging/posts/types/polls.pb.go b/x/staging/posts/types/polls.pb.go
index 167d466d..2aaf835c 100644
--- a/x/staging/posts/types/polls.pb.go
+++ b/x/staging/posts/types/polls.pb.go
@@ -27,55 +27,56 @@ var _ = time.Kitchen
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
-// ProvidedAnswer contains the data of a single poll answer inserted by the creator
+// ProvidedAnswer contains the data of a single poll answer inserted by the
+// creator
 type ProvidedAnswer struct {
 	ID   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id" yaml:"id"`
 	Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text" yaml:"text"`
 }
 
-func (answer *ProvidedAnswer) Reset()         { *answer = ProvidedAnswer{} }
-func (answer *ProvidedAnswer) String() string { return proto.CompactTextString(answer) }
-func (*ProvidedAnswer) ProtoMessage()         {}
+func (m *ProvidedAnswer) Reset()         { *m = ProvidedAnswer{} }
+func (m *ProvidedAnswer) String() string { return proto.CompactTextString(m) }
+func (*ProvidedAnswer) ProtoMessage()    {}
 func (*ProvidedAnswer) Descriptor() ([]byte, []int) {
 	return fileDescriptor_397fcd2757705694, []int{0}
 }
-func (answer *ProvidedAnswer) XXX_Unmarshal(b []byte) error {
-	return answer.Unmarshal(b)
+func (m *ProvidedAnswer) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
 }
-func (answer *ProvidedAnswer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ProvidedAnswer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ProvidedAnswer.Marshal(b, answer, deterministic)
+		return xxx_messageInfo_ProvidedAnswer.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := answer.MarshalToSizedBuffer(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (answer *ProvidedAnswer) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ProvidedAnswer.Merge(answer, src)
+func (m *ProvidedAnswer) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ProvidedAnswer.Merge(m, src)
 }
-func (answer *ProvidedAnswer) XXX_Size() int {
-	return answer.Size()
+func (m *ProvidedAnswer) XXX_Size() int {
+	return m.Size()
 }
-func (answer *ProvidedAnswer) XXX_DiscardUnknown() {
-	xxx_messageInfo_ProvidedAnswer.DiscardUnknown(answer)
+func (m *ProvidedAnswer) XXX_DiscardUnknown() {
+	xxx_messageInfo_ProvidedAnswer.DiscardUnknown(m)
 }
 
 var xxx_messageInfo_ProvidedAnswer proto.InternalMessageInfo
 
-func (answer *ProvidedAnswer) GetID() string {
-	if answer != nil {
-		return answer.ID
+func (m *ProvidedAnswer) GetID() string {
+	if m != nil {
+		return m.ID
 	}
 	return ""
 }
 
-func (answer *ProvidedAnswer) GetText() string {
-	if answer != nil {
-		return answer.Text
+func (m *ProvidedAnswer) GetText() string {
+	if m != nil {
+		return m.Text
 	}
 	return ""
 }
@@ -266,9 +267,9 @@ var fileDescriptor_397fcd2757705694 = []byte{
 	0x00, 0xff, 0xff, 0xa3, 0x96, 0xa9, 0x49, 0xd0, 0x03, 0x00, 0x00,
 }
 
-func (answer *ProvidedAnswer) Equal(that interface{}) bool {
+func (this *ProvidedAnswer) Equal(that interface{}) bool {
 	if that == nil {
-		return answer == nil
+		return this == nil
 	}
 
 	that1, ok := that.(*ProvidedAnswer)
@@ -281,14 +282,14 @@ func (answer *ProvidedAnswer) Equal(that interface{}) bool {
 		}
 	}
 	if that1 == nil {
-		return answer == nil
-	} else if answer == nil {
+		return this == nil
+	} else if this == nil {
 		return false
 	}
-	if answer.ID != that1.ID {
+	if this.ID != that1.ID {
 		return false
 	}
-	if answer.Text != that1.Text {
+	if this.Text != that1.Text {
 		return false
 	}
 	return true
@@ -369,37 +370,37 @@ func (this *UserAnswer) Equal(that interface{}) bool {
 	}
 	return true
 }
-func (answer *ProvidedAnswer) Marshal() (dAtA []byte, err error) {
-	size := answer.Size()
+func (m *ProvidedAnswer) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := answer.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
 	return dAtA[:n], nil
 }
 
-func (answer *ProvidedAnswer) MarshalTo(dAtA []byte) (int, error) {
-	size := answer.Size()
-	return answer.MarshalToSizedBuffer(dAtA[:size])
+func (m *ProvidedAnswer) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (answer *ProvidedAnswer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ProvidedAnswer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(answer.Text) > 0 {
-		i -= len(answer.Text)
-		copy(dAtA[i:], answer.Text)
-		i = encodeVarintPolls(dAtA, i, uint64(len(answer.Text)))
+	if len(m.Text) > 0 {
+		i -= len(m.Text)
+		copy(dAtA[i:], m.Text)
+		i = encodeVarintPolls(dAtA, i, uint64(len(m.Text)))
 		i--
 		dAtA[i] = 0x12
 	}
-	if len(answer.ID) > 0 {
-		i -= len(answer.ID)
-		copy(dAtA[i:], answer.ID)
-		i = encodeVarintPolls(dAtA, i, uint64(len(answer.ID)))
+	if len(m.ID) > 0 {
+		i -= len(m.ID)
+		copy(dAtA[i:], m.ID)
+		i = encodeVarintPolls(dAtA, i, uint64(len(m.ID)))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -535,17 +536,17 @@ func encodeVarintPolls(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
-func (answer *ProvidedAnswer) Size() (n int) {
-	if answer == nil {
+func (m *ProvidedAnswer) Size() (n int) {
+	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(answer.ID)
+	l = len(m.ID)
 	if l > 0 {
 		n += 1 + l + sovPolls(uint64(l))
 	}
-	l = len(answer.Text)
+	l = len(m.Text)
 	if l > 0 {
 		n += 1 + l + sovPolls(uint64(l))
 	}
@@ -608,7 +609,7 @@ func sovPolls(x uint64) (n int) {
 func sozPolls(x uint64) (n int) {
 	return sovPolls(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
-func (answer *ProvidedAnswer) Unmarshal(dAtA []byte) error {
+func (m *ProvidedAnswer) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -667,7 +668,7 @@ func (answer *ProvidedAnswer) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			answer.ID = string(dAtA[iNdEx:postIndex])
+			m.ID = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -699,7 +700,7 @@ func (answer *ProvidedAnswer) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			answer.Text = string(dAtA[iNdEx:postIndex])
+			m.Text = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -1006,7 +1007,7 @@ func (m *UserAnswer) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ProvidedAnswers", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Answers", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
diff --git a/x/staging/posts/types/query.pb.go b/x/staging/posts/types/query.pb.go
index fa8397a3..f44a7889 100644
--- a/x/staging/posts/types/query.pb.go
+++ b/x/staging/posts/types/query.pb.go
@@ -2754,7 +2754,7 @@ func (m *QueryUserAnswersResponse) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ProvidedAnswers", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Answers", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {


Test patch:
diff --git a/x/profiles/keeper/genesis_test.go b/x/profiles/keeper/genesis_test.go
index ce10a6f8..bb44f830 100644
--- a/x/profiles/keeper/genesis_test.go
+++ b/x/profiles/keeper/genesis_test.go
@@ -91,7 +91,7 @@ func (suite *KeeperTestSuite) Test_ExportGenesis() {
 				params := types.NewParams(
 					types.NewNicknameParams(sdk.NewInt(100), sdk.NewInt(200)),
 					types.NewDTagParams("regex", sdk.NewInt(100), sdk.NewInt(200)),
-					sdk.NewInt(1000),
+					types.NewBioParams(sdk.NewInt(1000)),
 				)
 				suite.k.SetParams(ctx, params)
 				suite.k.SetPort(ctx, "port-id")
@@ -168,7 +168,7 @@ func (suite *KeeperTestSuite) Test_ExportGenesis() {
 				types.NewParams(
 					types.NewNicknameParams(sdk.NewInt(100), sdk.NewInt(200)),
 					types.NewDTagParams("regex", sdk.NewInt(100), sdk.NewInt(200)),
-					sdk.NewInt(1000),
+					types.NewBioParams(sdk.NewInt(1000)),
 				),
 				"port-id",
 				[]types.ChainLink{
@@ -360,7 +360,7 @@ func (suite *KeeperTestSuite) Test_InitGenesis() {
 				types.NewParams(
 					types.NewNicknameParams(sdk.NewInt(100), sdk.NewInt(200)),
 					types.NewDTagParams("regex", sdk.NewInt(100), sdk.NewInt(200)),
-					sdk.NewInt(1000),
+					types.NewBioParams(sdk.NewInt(1000)),
 				),
 				"profiles-port-id",
 				[]types.ChainLink{
@@ -432,7 +432,7 @@ func (suite *KeeperTestSuite) Test_InitGenesis() {
 				params := types.NewParams(
 					types.NewNicknameParams(sdk.NewInt(100), sdk.NewInt(200)),
 					types.NewDTagParams("regex", sdk.NewInt(100), sdk.NewInt(200)),
-					sdk.NewInt(1000),
+					types.NewBioParams(sdk.NewInt(1000)),
 				)
 				suite.Require().Equal(params, suite.k.GetParams(ctx))
 
diff --git a/x/profiles/keeper/keeper_params_test.go b/x/profiles/keeper/keeper_params_test.go
index 95f0fa82..38eb456a 100644
--- a/x/profiles/keeper/keeper_params_test.go
+++ b/x/profiles/keeper/keeper_params_test.go
@@ -10,7 +10,7 @@ func (suite *KeeperTestSuite) TestKeeper_SetParams() {
 	params := types.NewParams(
 		types.NewNicknameParams(sdk.NewInt(3), sdk.NewInt(1000)),
 		types.NewDTagParams("^[A-Za-z0-9_]+$", sdk.NewInt(3), sdk.NewInt(1000)),
-		sdk.NewInt(1000),
+		types.NewBioParams(sdk.NewInt(1000)),
 	)
 	suite.k.SetParams(suite.ctx, params)
 
@@ -31,7 +31,7 @@ func (suite *KeeperTestSuite) TestKeeper_GetParams() {
 				params := types.NewParams(
 					types.NewNicknameParams(sdk.NewInt(3), sdk.NewInt(1000)),
 					types.NewDTagParams("^[A-Za-z0-9_]+$", sdk.NewInt(3), sdk.NewInt(1000)),
-					sdk.NewInt(1000),
+					types.NewBioParams(sdk.NewInt(1000)),
 				)
 				suite.k.SetParams(ctx, params)
 			},
@@ -39,7 +39,7 @@ func (suite *KeeperTestSuite) TestKeeper_GetParams() {
 			expParams: types.NewParams(
 				types.NewNicknameParams(sdk.NewInt(3), sdk.NewInt(1000)),
 				types.NewDTagParams("^[A-Za-z0-9_]+$", sdk.NewInt(3), sdk.NewInt(1000)),
-				sdk.NewInt(1000),
+				types.NewBioParams(sdk.NewInt(1000)),
 			),
 		},
 		{
diff --git a/x/profiles/types/genesis_test.go b/x/profiles/types/genesis_test.go
index 6059d6e8..e5d442b0 100644
--- a/x/profiles/types/genesis_test.go
+++ b/x/profiles/types/genesis_test.go
@@ -32,7 +32,7 @@ func TestValidateGenesis(t *testing.T) {
 				types.NewParams(
 					types.NewNicknameParams(sdk.NewInt(-1), sdk.NewInt(10)),
 					types.DefaultDTagParams(),
-					types.DefaultMaxBioLength,
+					types.DefaultBioParams(),
 				),
 				types.IBCPortID,
 				nil,
diff --git a/x/profiles/types/models_params_test.go b/x/profiles/types/models_params_test.go
index f875179c..2128df55 100644
--- a/x/profiles/types/models_params_test.go
+++ b/x/profiles/types/models_params_test.go
@@ -20,7 +20,7 @@ func TestValidateParams(t *testing.T) {
 			params: types.NewParams(
 				types.NewNicknameParams(sdk.NewInt(1), sdk.NewInt(1000)),
 				types.DefaultDTagParams(),
-				types.DefaultMaxBioLength,
+				types.DefaultBioParams(),
 			),
 			shouldErr: true,
 		},
@@ -29,18 +29,18 @@ func TestValidateParams(t *testing.T) {
 			params: types.NewParams(
 				types.DefaultNicknameParams(),
 				types.NewDTagParams("regEx", sdk.NewInt(3), sdk.NewInt(-30)),
-				types.DefaultMaxBioLength,
+				types.DefaultBioParams(),
 			),
 			shouldErr: true,
 		},
 		{
 			name:      "invalid bio param returns error",
-			params:    types.NewParams(types.DefaultNicknameParams(), types.DefaultDTagParams(), sdk.NewInt(-1000)),
+			params:    types.NewParams(types.DefaultNicknameParams(), types.DefaultDTagParams(), types.NewBioParams(sdk.NewInt(-1000))),
 			shouldErr: true,
 		},
 		{
 			name:      "valid params return no error",
-			params:    types.NewParams(types.DefaultNicknameParams(), types.DefaultDTagParams(), types.DefaultMaxBioLength),
+			params:    types.NewParams(types.DefaultNicknameParams(), types.DefaultDTagParams(), types.DefaultBioParams()),
 			shouldErr: false,
 		},
 	}
@@ -141,17 +141,17 @@ func TestValidateDTagParams(t *testing.T) {
 func TestValidateBioParams(t *testing.T) {
 	testCases := []struct {
 		name      string
-		params    sdk.Int
+		params    types.BioParams
 		shouldErr bool
 	}{
 		{
 			name:      "invalid value returns error",
-			params:    sdk.NewInt(-1000),
+			params:    types.NewBioParams(sdk.NewInt(-1000)),
 			shouldErr: true,
 		},
 		{
 			name:      "valid value returns no error",
-			params:    sdk.NewInt(1000),
+			params:    types.NewBioParams(sdk.NewInt(1000)),
 			shouldErr: false,
 		},
 	}