(no commit message provided)

api/did/v1/state.cosmos_orm.go

@@ -17,6 +17,9 @@ type AliasesTable interface {
 	Has(ctx context.Context, id string) (found bool, err error)
 	// Get returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
 	Get(ctx context.Context, id string) (*Aliases, error)
+	HasByHandle(ctx context.Context, handle string) (found bool, err error)
+	// GetByHandle returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByHandle(ctx context.Context, handle string) (*Aliases, error)
 	List(ctx context.Context, prefixKey AliasesIndexKey, opts ...ormlist.Option) (AliasesIterator, error)
 	ListRange(ctx context.Context, from, to AliasesIndexKey, opts ...ormlist.Option) (AliasesIterator, error)
 	DeleteBy(ctx context.Context, prefixKey AliasesIndexKey) error
@@ -57,6 +60,19 @@ func (this AliasesIdIndexKey) WithId(id string) AliasesIdIndexKey {
 	return this
 }
 
+type AliasesHandleIndexKey struct {
+	vs []interface{}
+}
+
+func (x AliasesHandleIndexKey) id() uint32            { return 1 }
+func (x AliasesHandleIndexKey) values() []interface{} { return x.vs }
+func (x AliasesHandleIndexKey) aliasesIndexKey()      {}
+
+func (this AliasesHandleIndexKey) WithHandle(handle string) AliasesHandleIndexKey {
+	this.vs = []interface{}{handle}
+	return this
+}
+
 type aliasesTable struct {
 	table ormtable.Table
 }
@@ -93,6 +109,26 @@ func (this aliasesTable) Get(ctx context.Context, id string) (*Aliases, error) {
 	return &aliases, nil
 }
 
+func (this aliasesTable) HasByHandle(ctx context.Context, handle string) (found bool, err error) {
+	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
+		handle,
+	)
+}
+
+func (this aliasesTable) GetByHandle(ctx context.Context, handle string) (*Aliases, error) {
+	var aliases Aliases
+	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &aliases,
+		handle,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &aliases, nil
+}
+
 func (this aliasesTable) List(ctx context.Context, prefixKey AliasesIndexKey, opts ...ormlist.Option) (AliasesIterator, error) {
 	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
 	return AliasesIterator{it}, err

api/did/v1/state.pulsar.go

@@ -5126,7 +5126,7 @@ var file_did_v1_state_proto_rawDesc = []byte{
 	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x1a, 0x17, 0x63, 0x6f,
 	0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6f, 0x72, 0x6d, 0x2f, 0x76, 0x31, 0x2f, 0x6f, 0x72, 0x6d, 0x2e,
 	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x14, 0x64, 0x69, 0x64, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65,
-	0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x99, 0x01, 0x0a, 0x07,
+	0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa7, 0x01, 0x0a, 0x07,
 	0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20,
 	0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69,
 	0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x12,
@@ -5135,88 +5135,89 @@ var file_did_v1_state_proto_rawDesc = []byte{
 	0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6e,
 	0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x78, 0x70, 0x69, 0x72,
 	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x78, 0x70,
-	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a,
+	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x1c, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x16, 0x0a,
-	0x04, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x22, 0x80, 0x02, 0x0a, 0x09, 0x41, 0x73, 0x73, 0x65,
+	0x04, 0x0a, 0x02, 0x69, 0x64, 0x12, 0x0c, 0x0a, 0x06, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x10,
-	0x72, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x01, 0x18, 0x01, 0x18, 0x01, 0x22, 0x80, 0x02, 0x0a, 0x09, 0x41, 0x73, 0x73, 0x65, 0x72, 0x74,
-	0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x74, 0x79, 0x70,
+	0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x54, 0x79, 0x70, 0x65,
+	0x02, 0x69, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
-	0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x18, 0x03,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1e,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c,
+	0x0a, 0x0a, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01,
-	0x12, 0x3b, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03,
+	0x28, 0x0c, 0x52, 0x0a, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x3b,
-	0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x65,
+	0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b,
-	0x72, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e,
+	0x32, 0x1f, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x72, 0x74,
-	0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1e, 0x0a,
+	0x69, 0x6f, 0x6e, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
-	0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1e, 0x0a, 0x0a, 0x63,
-	0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x1a, 0x3b, 0x0a,
+	0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
+	0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d,
-	0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
-	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
-	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
-	0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x22, 0x94, 0x01, 0x0a, 0x0b, 0x41,
+	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08,
-	0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64,
+	0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x22, 0x94, 0x01, 0x0a, 0x0b, 0x41, 0x74, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65,
+	0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
-	0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f,
-	0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03,
+	0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x54,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70,
+	0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01,
-	0x72, 0x6f, 0x6f, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f,
+	0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f,
-	0x66, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x18,
+	0x6f, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12,
-	0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65,
+	0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x18, 0x05, 0x20,
-	0x72, 0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x18,
+	0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x3a,
-	0x03, 0x22, 0xaf, 0x01, 0x0a, 0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72,
+	0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03, 0x22,
+	0xaf, 0x01, 0x0a, 0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x0e,
+	0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10,
+	0x0a, 0x03, 0x64, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x64, 0x69, 0x64,
+	0x12, 0x30, 0x0a, 0x14, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x6d,
+	0x75, 0x6c, 0x74, 0x69, 0x62, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12,
+	0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x62, 0x61,
+	0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x69, 0x64, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x76, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x69, 0x64, 0x12,
+	0x20, 0x0a, 0x0b, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e,
+	0x74, 0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x18,
+	0x04, 0x22, 0x8b, 0x03, 0x0a, 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
 	0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64,
 	0x12, 0x10, 0x0a, 0x03, 0x64, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x64,
-	0x69, 0x64, 0x12, 0x30, 0x0a, 0x14, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
+	0x69, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65,
-	0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x62, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x54, 0x79, 0x70,
-	0x52, 0x12, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4d, 0x75, 0x6c, 0x74, 0x69,
+	0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x62, 0x61, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x69,
+	0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x41,
-	0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x76, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x69,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f,
-	0x64, 0x12, 0x20, 0x0a, 0x0b, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74,
+	0x6c, 0x6c, 0x65, 0x72, 0x5f, 0x64, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72,
+	0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x44, 0x69, 0x64, 0x12, 0x30, 0x0a,
-	0x69, 0x6e, 0x74, 0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69,
+	0x14, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x6d, 0x75, 0x6c, 0x74,
-	0x64, 0x18, 0x04, 0x22, 0x8b, 0x03, 0x0a, 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x69, 0x62, 0x61, 0x73, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x75, 0x62,
-	0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02,
+	0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x62, 0x61, 0x73, 0x65, 0x12,
-	0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x4d, 0x0a, 0x0f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x6a, 0x77,
-	0x03, 0x64, 0x69, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x74, 0x79,
+	0x6b, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76,
-	0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x54,
+	0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x75, 0x62,
-	0x79, 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x61, 0x64, 0x64,
+	0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4a, 0x77, 0x6b, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
-	0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x69,
+	0x0d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4a, 0x77, 0x6b, 0x73, 0x12, 0x1d,
-	0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74,
+	0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x01,
-	0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x5f, 0x64, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
+	0x28, 0x04, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x64, 0x1a, 0x40, 0x0a,
-	0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x44, 0x69, 0x64, 0x12,
+	0x12, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4a, 0x77, 0x6b, 0x73, 0x45, 0x6e,
-	0x30, 0x0a, 0x14, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x6d, 0x75,
+	0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x6c, 0x74, 0x69, 0x62, 0x61, 0x73, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70,
+	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
-	0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x62, 0x61, 0x73,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x3a,
-	0x65, 0x12, 0x4d, 0x0a, 0x0f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
+	0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x05, 0x22,
-	0x6a, 0x77, 0x6b, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x64, 0x69, 0x64,
+	0x9e, 0x01, 0x0a, 0x07, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69,
-	0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73,
-	0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4a, 0x77, 0x6b, 0x73, 0x45, 0x6e, 0x74, 0x72,
+	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x79, 0x52, 0x0d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4a, 0x77, 0x6b, 0x73,
+	0x09, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x29,
-	0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x08,
+	0x0a, 0x10, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69,
-	0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x64, 0x1a,
+	0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x40, 0x0a, 0x12, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x4a, 0x77, 0x6b, 0x73,
+	0x65, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e,
-	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x5f, 0x64, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x44, 0x69, 0x64,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
+	0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x06,
-	0x01, 0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x18,
+	0x42, 0x7a, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x42, 0x0a,
-	0x05, 0x22, 0x9e, 0x01, 0x0a, 0x07, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x0e, 0x0a,
+	0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x27, 0x67, 0x69,
-	0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a,
+	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6f, 0x6e, 0x73, 0x6f, 0x6e, 0x72, 0x2f,
-	0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20,
+	0x68, 0x77, 0x61, 0x79, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x64, 0x69, 0x64, 0x2f, 0x76, 0x31, 0x3b,
-	0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65,
+	0x64, 0x69, 0x64, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x44, 0x58, 0x58, 0xaa, 0x02, 0x06, 0x44, 0x69,
-	0x12, 0x29, 0x0a, 0x10, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x65, 0x6e, 0x64, 0x70,
+	0x64, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, 0x44, 0x69, 0x64, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x12,
-	0x6f, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x65, 0x72, 0x76,
+	0x44, 0x69, 0x64, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
-	0x69, 0x63, 0x65, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63,
+	0x74, 0x61, 0xea, 0x02, 0x07, 0x44, 0x69, 0x64, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72,
-	0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x5f, 0x64, 0x69, 0x64, 0x18, 0x04, 0x20,
+	0x6f, 0x74, 0x6f, 0x33,
-	0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x44,
-	0x69, 0x64, 0x3a, 0x0e, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x08, 0x0a, 0x04, 0x0a, 0x02, 0x69, 0x64,
-	0x18, 0x06, 0x42, 0x7a, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31,
-	0x42, 0x0a, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x27,
-	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6f, 0x6e, 0x73, 0x6f, 0x6e,
-	0x72, 0x2f, 0x68, 0x77, 0x61, 0x79, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x64, 0x69, 0x64, 0x2f, 0x76,
-	0x31, 0x3b, 0x64, 0x69, 0x64, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x44, 0x58, 0x58, 0xaa, 0x02, 0x06,
-	0x44, 0x69, 0x64, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, 0x44, 0x69, 0x64, 0x5c, 0x56, 0x31, 0xe2,
-	0x02, 0x12, 0x44, 0x69, 0x64, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
-	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x44, 0x69, 0x64, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (

api/did/v1/tx.pulsar.go

@@ -3391,33 +3391,33 @@ var file_did_v1_tx_proto_rawDesc = []byte{
 	0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22,
 	0x23, 0x0a, 0x21, 0x4d, 0x73, 0x67, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61,
 	0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x32, 0xa0, 0x02, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x48, 0x0a, 0x0c,
+	0x6f, 0x6e, 0x73, 0x65, 0x32, 0x9e, 0x02, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x48, 0x0a, 0x0c,
 	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x17, 0x2e, 0x64,
 	0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50,
 	0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x1f, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d,
 	0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x60, 0x0a, 0x14, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x12, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
-	0x6c, 0x69, 0x7a, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x1f,
+	0x65, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x64,
-	0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x69,
+	0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c,
-	0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x1a,
+	0x69, 0x7a, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x1a, 0x27, 0x2e,
-	0x27, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74,
+	0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61,
-	0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72,
+	0x6c, 0x69, 0x7a, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x65,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x66, 0x0a, 0x16, 0x41, 0x75, 0x74, 0x68,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x66, 0x0a, 0x16, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e,
-	0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c,
+	0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72,
-	0x65, 0x72, 0x12, 0x21, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x41,
+	0x12, 0x21, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x41, 0x75, 0x74,
-	0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72,
+	0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c,
-	0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x1a, 0x29, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d,
+	0x6c, 0x65, 0x72, 0x1a, 0x29, 0x2e, 0x64, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67,
-	0x73, 0x67, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x43, 0x6f,
+	0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74,
-	0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05,
-	0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0x77, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x64,
+	0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0x77, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x69, 0x64,
-	0x69, 0x64, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
+	0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x27,
-	0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6f, 0x6e, 0x73,
+	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6f, 0x6e, 0x73, 0x6f, 0x6e,
-	0x6f, 0x6e, 0x72, 0x2f, 0x68, 0x77, 0x61, 0x79, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x64, 0x69, 0x64,
+	0x72, 0x2f, 0x68, 0x77, 0x61, 0x79, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x64, 0x69, 0x64, 0x2f, 0x76,
-	0x2f, 0x76, 0x31, 0x3b, 0x64, 0x69, 0x64, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x44, 0x58, 0x58, 0xaa,
+	0x31, 0x3b, 0x64, 0x69, 0x64, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x44, 0x58, 0x58, 0xaa, 0x02, 0x06,
-	0x02, 0x06, 0x44, 0x69, 0x64, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, 0x44, 0x69, 0x64, 0x5c, 0x56,
+	0x44, 0x69, 0x64, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, 0x44, 0x69, 0x64, 0x5c, 0x56, 0x31, 0xe2,
-	0x31, 0xe2, 0x02, 0x12, 0x44, 0x69, 0x64, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65,
+	0x02, 0x12, 0x44, 0x69, 0x64, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
-	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x44, 0x69, 0x64, 0x3a, 0x3a, 0x56, 0x31,
+	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x44, 0x69, 0x64, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -3445,10 +3445,10 @@ var file_did_v1_tx_proto_goTypes = []interface{}{
 var file_did_v1_tx_proto_depIdxs = []int32{
 	6, // 0: did.v1.MsgUpdateParams.params:type_name -> did.v1.Params
 	0, // 1: did.v1.Msg.UpdateParams:input_type -> did.v1.MsgUpdateParams
-	2, // 2: did.v1.Msg.InitializeController:input_type -> did.v1.MsgInitializeController
+	2, // 2: did.v1.Msg.RegisterController:input_type -> did.v1.MsgInitializeController
 	4, // 3: did.v1.Msg.AuthenticateController:input_type -> did.v1.MsgAuthenticateController
 	1, // 4: did.v1.Msg.UpdateParams:output_type -> did.v1.MsgUpdateParamsResponse
-	3, // 5: did.v1.Msg.InitializeController:output_type -> did.v1.MsgInitializeControllerResponse
+	3, // 5: did.v1.Msg.RegisterController:output_type -> did.v1.MsgInitializeControllerResponse
 	5, // 6: did.v1.Msg.AuthenticateController:output_type -> did.v1.MsgAuthenticateControllerResponse
 	4, // [4:7] is the sub-list for method output_type
 	1, // [1:4] is the sub-list for method input_type

api/did/v1/tx_grpc.pb.go

@@ -20,7 +20,7 @@ const _ = grpc.SupportPackageIsVersion7
 
 const (
 	Msg_UpdateParams_FullMethodName           = "/did.v1.Msg/UpdateParams"
-	Msg_InitializeController_FullMethodName   = "/did.v1.Msg/InitializeController"
+	Msg_RegisterController_FullMethodName     = "/did.v1.Msg/RegisterController"
 	Msg_AuthenticateController_FullMethodName = "/did.v1.Msg/AuthenticateController"
 )
 
@@ -32,8 +32,8 @@ type MsgClient interface {
 	//
 	// Since: cosmos-sdk 0.47
 	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
-	// InitializeController initializes a controller with the given assertions, keyshares, and verifications.
+	// RegisterController initializes a controller with the given authentication set, address, cid, publicKey, and user-defined alias.
-	InitializeController(ctx context.Context, in *MsgInitializeController, opts ...grpc.CallOption) (*MsgInitializeControllerResponse, error)
+	RegisterController(ctx context.Context, in *MsgInitializeController, opts ...grpc.CallOption) (*MsgInitializeControllerResponse, error)
 	// AuthenticateController asserts the given controller is the owner of the given address.
 	AuthenticateController(ctx context.Context, in *MsgAuthenticateController, opts ...grpc.CallOption) (*MsgAuthenticateControllerResponse, error)
 }
@@ -55,9 +55,9 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts
 	return out, nil
 }
 
-func (c *msgClient) InitializeController(ctx context.Context, in *MsgInitializeController, opts ...grpc.CallOption) (*MsgInitializeControllerResponse, error) {
+func (c *msgClient) RegisterController(ctx context.Context, in *MsgInitializeController, opts ...grpc.CallOption) (*MsgInitializeControllerResponse, error) {
 	out := new(MsgInitializeControllerResponse)
-	err := c.cc.Invoke(ctx, Msg_InitializeController_FullMethodName, in, out, opts...)
+	err := c.cc.Invoke(ctx, Msg_RegisterController_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -81,8 +81,8 @@ type MsgServer interface {
 	//
 	// Since: cosmos-sdk 0.47
 	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
-	// InitializeController initializes a controller with the given assertions, keyshares, and verifications.
+	// RegisterController initializes a controller with the given authentication set, address, cid, publicKey, and user-defined alias.
-	InitializeController(context.Context, *MsgInitializeController) (*MsgInitializeControllerResponse, error)
+	RegisterController(context.Context, *MsgInitializeController) (*MsgInitializeControllerResponse, error)
 	// AuthenticateController asserts the given controller is the owner of the given address.
 	AuthenticateController(context.Context, *MsgAuthenticateController) (*MsgAuthenticateControllerResponse, error)
 	mustEmbedUnimplementedMsgServer()
@@ -95,8 +95,8 @@ type UnimplementedMsgServer struct {
 func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
 }
-func (UnimplementedMsgServer) InitializeController(context.Context, *MsgInitializeController) (*MsgInitializeControllerResponse, error) {
+func (UnimplementedMsgServer) RegisterController(context.Context, *MsgInitializeController) (*MsgInitializeControllerResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method InitializeController not implemented")
+	return nil, status.Errorf(codes.Unimplemented, "method RegisterController not implemented")
 }
 func (UnimplementedMsgServer) AuthenticateController(context.Context, *MsgAuthenticateController) (*MsgAuthenticateControllerResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method AuthenticateController not implemented")
@@ -132,20 +132,20 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_InitializeController_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _Msg_RegisterController_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgInitializeController)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).InitializeController(ctx, in)
+		return srv.(MsgServer).RegisterController(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: Msg_InitializeController_FullMethodName,
+		FullMethod: Msg_RegisterController_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).InitializeController(ctx, req.(*MsgInitializeController))
+		return srv.(MsgServer).RegisterController(ctx, req.(*MsgInitializeController))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -180,8 +180,8 @@ var Msg_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _Msg_UpdateParams_Handler,
 		},
 		{
-			MethodName: "InitializeController",
+			MethodName: "RegisterController",
-			Handler:    _Msg_InitializeController_Handler,
+			Handler:    _Msg_RegisterController_Handler,
 		},
 		{
 			MethodName: "AuthenticateController",

go.mod

@@ -42,6 +42,7 @@ require (
 	cosmossdk.io/x/nft v0.1.0
 	cosmossdk.io/x/tx v0.13.3
 	cosmossdk.io/x/upgrade v0.1.1
+	github.com/btcsuite/btcd/btcec/v2 v2.3.3
 	github.com/cometbft/cometbft v0.38.8
 	github.com/cosmos/cosmos-db v1.0.2
 	github.com/cosmos/cosmos-proto v1.0.0-beta.5
@@ -56,6 +57,7 @@ require (
 	github.com/grpc-ecosystem/grpc-gateway v1.16.0
 	github.com/ipfs/kubo v0.29.0
 	github.com/joho/godotenv v1.5.1
+	github.com/onsonr/crypto v1.5.0
 	github.com/spf13/cast v1.6.0
 	github.com/spf13/cobra v1.8.0
 	github.com/spf13/pflag v1.0.5
@@ -64,6 +66,7 @@ require (
 	github.com/strangelove-ventures/poa v0.50.0
 	github.com/strangelove-ventures/tokenfactory v0.50.0
 	github.com/stretchr/testify v1.9.0
+	golang.org/x/crypto v0.25.0
 	google.golang.org/genproto/googleapis/api v0.0.0-20240617180043-68d350f18fd4
 	google.golang.org/grpc v1.64.0
 	google.golang.org/protobuf v1.34.2
@@ -79,7 +82,6 @@ require (
 	github.com/99designs/keyring v1.2.1 // indirect
 	github.com/DataDog/datadog-go v3.2.0+incompatible // indirect
 	github.com/DataDog/zstd v1.5.5 // indirect
-	github.com/Microsoft/go-winio v0.6.2 // indirect
 	github.com/alecthomas/units v0.0.0-20231202071711-9a357b53e9c9 // indirect
 	github.com/aws/aws-sdk-go v1.44.224 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
@@ -87,9 +89,9 @@ require (
 	github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 // indirect
 	github.com/bits-and-blooms/bitset v1.13.0 // indirect
 	github.com/blang/semver/v4 v4.0.0 // indirect
-	github.com/btcsuite/btcd/btcec/v2 v2.3.3 // indirect
 	github.com/btcsuite/btcd/btcutil v1.1.5 // indirect
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect
+	github.com/bwesterb/go-ristretto v1.2.3 // indirect
 	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 	github.com/cespare/xxhash v1.1.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
@@ -102,6 +104,8 @@ require (
 	github.com/cockroachdb/redact v1.1.5 // indirect
 	github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect
 	github.com/cometbft/cometbft-db v0.9.1 // indirect
+	github.com/consensys/bavard v0.1.13 // indirect
+	github.com/consensys/gnark-crypto v0.12.1 // indirect
 	github.com/cosmos/btcutil v1.0.5 // indirect
 	github.com/cosmos/go-bip39 v1.0.0 // indirect
 	github.com/cosmos/gogogateway v1.2.0 // indirect
@@ -121,6 +125,7 @@ require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/dvsekhvalnov/jose2go v1.6.0 // indirect
 	github.com/emicklei/dot v1.6.1 // indirect
+	github.com/ethereum/go-ethereum v1.14.6 // indirect
 	github.com/facebookgo/atomicfile v0.0.0-20151019160806-2de1f203e7d5 // indirect
 	github.com/fatih/color v1.16.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
@@ -223,6 +228,7 @@ require (
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/go-testing-interface v1.14.1 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mmcloughlin/addchain v0.4.0 // indirect
 	github.com/mr-tron/base58 v1.2.0 // indirect
 	github.com/mtibben/percent v0.2.1 // indirect
 	github.com/multiformats/go-base32 v0.1.0 // indirect
@@ -283,7 +289,6 @@ require (
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.27.0 // indirect
 	go4.org v0.0.0-20230225012048-214862532bf5 // indirect
-	golang.org/x/crypto v0.25.0 // indirect
 	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 // indirect
 	golang.org/x/mod v0.18.0 // indirect
 	golang.org/x/net v0.26.0 // indirect
@@ -306,5 +311,6 @@ require (
 	lukechampine.com/blake3 v1.3.0 // indirect
 	nhooyr.io/websocket v1.8.10 // indirect
 	pgregory.net/rapid v1.1.0 // indirect
+	rsc.io/tmplfunc v0.0.3 // indirect
 	sigs.k8s.io/yaml v1.4.0 // indirect
 )

go.sum

@@ -901,6 +901,8 @@ github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtE
 github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
 github.com/bufbuild/protocompile v0.6.0 h1:Uu7WiSQ6Yj9DbkdnOe7U4mNKp58y9WDMKDn28/ZlunY=
 github.com/bufbuild/protocompile v0.6.0/go.mod h1:YNP35qEYoYGme7QMtz5SBCoN4kL4g12jTtjuzRNdjpE=
+github.com/bwesterb/go-ristretto v1.2.3 h1:1w53tCkGhCQ5djbat3+MH0BAQ5Kfgbt56UZQ/JMzngw=
+github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw=
@@ -967,6 +969,10 @@ github.com/cometbft/cometbft v0.38.8 h1:XyJ9Cu3xqap6xtNxiemrO8roXZ+KS2Zlu7qQ0w1t
 github.com/cometbft/cometbft v0.38.8/go.mod h1:xOoGZrtUT+A5izWfHSJgl0gYZUE7lu7Z2XIS1vWG/QQ=
 github.com/cometbft/cometbft-db v0.9.1 h1:MIhVX5ja5bXNHF8EYrThkG9F7r9kSfv8BX4LWaxWJ4M=
 github.com/cometbft/cometbft-db v0.9.1/go.mod h1:iliyWaoV0mRwBJoizElCwwRA9Tf7jZJOURcRZF9m60U=
+github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ=
+github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
+github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M=
+github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY=
 github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM=
 github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw=
 github.com/containerd/continuity v0.3.0 h1:nisirsYROK15TAMVukJOUyGJjz4BNQJBVsNvAXZJ/eg=
@@ -983,8 +989,6 @@ github.com/cosmos/cosmos-proto v1.0.0-beta.5 h1:eNcayDLpip+zVLRLYafhzLvQlSmyab+R
 github.com/cosmos/cosmos-proto v1.0.0-beta.5/go.mod h1:hQGLpiIUloJBMdQMMWb/4wRApmI9hjHH05nefC0Ojec=
 github.com/cosmos/cosmos-sdk v0.50.5 h1:MOEi+DKYgW67YaPgB+Pf+nHbD3V9S/ayitRKJYLfGIA=
 github.com/cosmos/cosmos-sdk v0.50.5/go.mod h1:oV/k6GJgXV9QPoM2fsYDPPsyPBgQbdotv532O6Mz1OQ=
-github.com/cosmos/cosmos-sdk v0.50.7 h1:LsBGKxifENR/DN4E1RZaitsyL93HU44x0p8EnMHp4V4=
-github.com/cosmos/cosmos-sdk v0.50.7/go.mod h1:84xDDJEHttRT7NDGwBaUOLVOMN0JNE9x7NbsYIxXs1s=
 github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY=
 github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw=
 github.com/cosmos/gogogateway v1.2.0 h1:Ae/OivNhp8DqBi/sh2A8a1D0y638GpL3tkmLQAiKxTE=
@@ -1086,6 +1090,8 @@ github.com/envoyproxy/protoc-gen-validate v0.10.0/go.mod h1:DRjgyB0I43LtJapqN6Ni
 github.com/envoyproxy/protoc-gen-validate v0.10.1/go.mod h1:DRjgyB0I43LtJapqN6NiRwroiAU2PaFuvk/vjgh61ss=
 github.com/envoyproxy/protoc-gen-validate v1.0.1/go.mod h1:0vj8bNkYbSTNS2PIyH87KZaeN4x9zpL9Qt8fQC7d+vs=
 github.com/envoyproxy/protoc-gen-validate v1.0.2/go.mod h1:GpiZQP3dDbg4JouG/NNS7QWXpgx6x8QiMKdmN72jogE=
+github.com/ethereum/go-ethereum v1.14.6 h1:ZTxnErSopkDyxdvB8zW/KcK+/AVrdil/TzoWXVKaaC8=
+github.com/ethereum/go-ethereum v1.14.6/go.mod h1:hglUZo/5pVIYXNyYjWzsAUDpT/zI+WbWo/Nih7ot+G0=
 github.com/facebookgo/atomicfile v0.0.0-20151019160806-2de1f203e7d5 h1:BBso6MBKW8ncyZLv37o+KNyy0HrrHgfnOaGQC2qvN+A=
 github.com/facebookgo/atomicfile v0.0.0-20151019160806-2de1f203e7d5/go.mod h1:JpoxHjuQauoxiFMl1ie8Xc/7TfLuMZ5eOCONd1sUBHg=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
@@ -1296,6 +1302,7 @@ github.com/google/s2a-go v0.1.3/go.mod h1:Ej+mSEMGRnqRzjc7VtF+jdBwYG5fuJfiZ8ELkj
 github.com/google/s2a-go v0.1.4/go.mod h1:Ej+mSEMGRnqRzjc7VtF+jdBwYG5fuJfiZ8ELkjEwM0A=
 github.com/google/s2a-go v0.1.7 h1:60BLSyTrOV4/haCDW4zb1guZItoSq8foHCXrAnjBo/o=
 github.com/google/s2a-go v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw=
+github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -1587,6 +1594,8 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
+github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
 github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw=
 github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
@@ -1692,6 +1701,9 @@ github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUb
 github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY=
+github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU=
+github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
@@ -1761,6 +1773,8 @@ github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7J
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.33.1 h1:dsYjIxxSR755MDmKVsaFQTE22ChNBcuuTWgkUDSubOk=
 github.com/onsi/gomega v1.33.1/go.mod h1:U4R44UsT+9eLIaYRB2a5qajjtQYn0hauxvRm16AVYg0=
+github.com/onsonr/crypto v1.5.0 h1:iAmjTdzuu6inJL48/gHsLcQsyq+GbnVaKSBxlkpkBnE=
+github.com/onsonr/crypto v1.5.0/go.mod h1:g77+cbK6mD5qILg4dN6d2X9fNtYrEUAOQ6JIlj12Um0=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/opencontainers/image-spec v1.1.0-rc5 h1:Ygwkfw9bpDvs+c9E34SdgGOj41dX/cbdlwvlWt0pnFI=
@@ -3008,6 +3022,8 @@ rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8
 rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
 rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
 rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU=
+rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA=
 sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=
 sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
 sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=

proto/did/v1/genesis.proto

@@ -17,17 +17,56 @@ message Params {
   option (gogoproto.equal) = true;
   option (gogoproto.goproto_stringer) = false;
 
-  // Property Allowlist
+  // Whitelisted Assets 
-  repeated string property_allowlist = 2;
+  repeated AssetInfo whitelisted_assets = 1;
 
-  // Whitelisted Verifications
+  // Whitelisted Blockchains
-  repeated string whitelisted_origins = 3;
+  repeated ChainInfo whitelisted_chains = 2;
+}
 
-  // Assertion Reward Rate
+// Meta represents 
-  double assertion_reward_rate = 4;
+message Meta {
-
+  option (amino.name) = "did/meta";
-  // Encryption Reward Rate
+  option (gogoproto.equal) = true;
-  double encryption_reward_rate = 5;
+  option (gogoproto.goproto_stringer) = false;
+  
+  // Key value data for the Property
+  map<string, string> data = 1;
 }
 
 
+message AssetInfo {
+    string denom = 1;
+    string asset_type = 2;
+    string origin_chain = 3;
+    string origin_denom = 4;
+    string origin_type = 5;
+    string symbol = 6;
+    int32 decimals = 7;
+    string description = 8;
+    string image = 9;
+    string coinGeckoId = 10;
+    bool enable = 11;
+    string path = 12;
+    string channel = 13;
+    string port = 14;
+    Meta counter_party = 15;
+}
+
+message ChainInfo {
+    string chain_id_cosmos = 1;
+    string chain_name = 2;
+    string symbol = 3;
+    string bechAccountPrefix = 4;
+    string bechValidatorPrefix = 5;
+    string origin_genesis_time = 6;
+    repeated Meta accountType = 7;
+    repeated Meta grpc_endpoint = 8;
+    repeated Meta lcd_endpoint = 9;
+    Meta explorer = 10;
+    string fee_base = 11;
+    repeated string fee_rate = 12;
+    int32 fee_init_gas_limit = 13;
+    bool fee_isSimulable = 14;
+    double simul_gas_multiply = 15;
+}

proto/did/v1/state.proto

@@ -11,6 +11,7 @@ message Aliases {
   option (cosmos.orm.v1.table) = {
     id: 1
     primary_key: {fields: "id"}
+    index: { id: 1, fields: "handle", unique: true }
     };
 
   // The unique identifier of the alias

proto/did/v1/tx.proto

@@ -16,8 +16,8 @@ service Msg {
     // Since: cosmos-sdk 0.47
     rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse);
 
-    // InitializeController initializes a controller with the given assertions, keyshares, and verifications.
+    // RegisterController initializes a controller with the given authentication set, address, cid, publicKey, and user-defined alias.
-    rpc InitializeController(MsgInitializeController) returns (MsgInitializeControllerResponse);
+    rpc RegisterController(MsgInitializeController) returns (MsgInitializeControllerResponse);
 
     // AuthenticateController asserts the given controller is the owner of the given address.
     rpc AuthenticateController(MsgAuthenticateController) returns (MsgAuthenticateControllerResponse);

proto/did/v1/types.proto

@@ -1,16 +1,17 @@
-// Copyright Tharsis Labs Ltd.(Evmos)
-// SPDX-License-Identifier:ENCL-1.0(https://github.com/evmos/evmos/blob/main/LICENSE)
 syntax = "proto3";
+
 package did.v1;
 
-import "cosmos_proto/cosmos.proto";
+import "cosmos/msg/v1/msg.proto";
-import "gogoproto/gogo.proto";
 import "did/v1/genesis.proto";
+import "gogoproto/gogo.proto";
+import "cosmos_proto/cosmos.proto";
 
 option go_package = "github.com/onsonr/hway/x/did/types";
 
-// DIDDocument defines a DID document
+
-message DIDDocument {
+// BaseDocument defines a DID document
+message BaseDocument {
   string id = 1;
   repeated VerificationMethod verification_methods = 2;
   repeated string authentication = 4;

x/did/keeper/server.go

@@ -3,7 +3,6 @@ package keeper
 import (
 	"context"
 
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 
 	"cosmossdk.io/errors"
@@ -21,12 +20,6 @@ func NewMsgServerImpl(keeper Keeper) types.MsgServer {
 	return &msgServer{k: keeper}
 }
 
-// InitializeController implements types.MsgServer.
-func (ms msgServer) InitializeController(goCtx context.Context, msg *types.MsgInitializeController) (*types.MsgInitializeControllerResponse, error) {
-	_ = sdk.UnwrapSDKContext(goCtx)
-	return &types.MsgInitializeControllerResponse{}, nil
-}
-
 // UpdateParams updates the x/did module parameters.
 func (ms msgServer) UpdateParams(ctx context.Context, msg *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
 	if ms.k.authority != msg.Authority {
@@ -42,3 +35,10 @@ func (ms msgServer) AuthenticateController(ctx context.Context, msg *types.MsgAu
 	panic("AuthenticateController is unimplemented")
 	return &types.MsgAuthenticateControllerResponse{}, nil
 }
+
+// RegisterController implements types.MsgServer.
+func (ms msgServer) RegisterController(ctx context.Context, msg *types.MsgInitializeController) (*types.MsgInitializeControllerResponse, error) {
+	// ctx := sdk.UnwrapSDKContext(goCtx)
+	panic("RegisterController is unimplemented")
+	return &types.MsgInitializeControllerResponse{}, nil
+}

x/did/types/bip32.go

@@ -0,0 +1,66 @@
+package types
+
+import (
+	"crypto/hmac"
+	"crypto/sha512"
+	"encoding/binary"
+	"errors"
+	"math/big"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+)
+
+// ComputePublicKey computes the public key of a child key given the extended public key, chain code, and index.
+func ComputePublicKey(extPubKey []byte, chainCode uint32, index int) ([]byte, error) {
+	// Check if the index is a hardened child key
+	if chainCode&0x80000000 != 0 && index < 0 {
+		return nil, errors.New("invalid index")
+	}
+
+	// Serialize the public key
+	pubKey, err := btcec.ParsePubKey(extPubKey)
+	if err != nil {
+		return nil, err
+	}
+	pubKeyBytes := pubKey.SerializeCompressed()
+
+	// Serialize the index
+	indexBytes := make([]byte, 4)
+	binary.BigEndian.PutUint32(indexBytes, uint32(index))
+
+	// Compute the HMAC-SHA512
+	mac := hmac.New(sha512.New, []byte{byte(chainCode)})
+	mac.Write(pubKeyBytes)
+	mac.Write(indexBytes)
+	I := mac.Sum(nil)
+
+	// Split I into two 32-byte sequences
+	IL := I[:32]
+
+	// Convert IL to a big integer
+	ilNum := new(big.Int).SetBytes(IL)
+
+	// Check if parse256(IL) >= n
+	curve := btcec.S256()
+	if ilNum.Cmp(curve.N) >= 0 {
+		return nil, errors.New("invalid child key")
+	}
+
+	// Compute the child public key
+	ilx, ily := curve.ScalarBaseMult(IL)
+	childX, childY := curve.Add(ilx, ily, pubKey.X(), pubKey.Y())
+	lx := newBigIntFieldVal(childX)
+	ly := newBigIntFieldVal(childY)
+
+	// Create the child public key
+	childPubKey := btcec.NewPublicKey(lx, ly)
+	childPubKeyBytes := childPubKey.SerializeCompressed()
+	return childPubKeyBytes, nil
+}
+
+// newBigIntFieldVal creates a new field value from a big integer.
+func newBigIntFieldVal(val *big.Int) *btcec.FieldVal {
+	lx := new(btcec.FieldVal)
+	lx.SetByteSlice(val.Bytes())
+	return lx
+}

x/did/types/genesis.go

@@ -25,18 +25,7 @@ func (gs GenesisState) Validate() error {
 
 // DefaultParams returns default module parameters.
 func DefaultParams() Params {
-	return Params{
+	return Params{}
-		PropertyAllowlist: []string{
-			"email",
-			"phone",
-		},
-		AssertionRewardRate:  0.35,
-		EncryptionRewardRate: 0.5,
-		WhitelistedOrigins: []string{
-			"sonr.local",
-			"sonr.id",
-		},
-	}
 }
 
 // Stringer method for Params.

x/did/types/keys.go

@@ -1,15 +1,19 @@
 package types
 
 import (
+	fmt "fmt"
+	"math/big"
+
 	"cosmossdk.io/collections"
+	"github.com/onsonr/crypto/core/curves"
+	"github.com/onsonr/crypto/signatures/ecdsa"
+	"golang.org/x/crypto/sha3"
 
 	ormv1alpha1 "cosmossdk.io/api/cosmos/orm/v1alpha1"
 )
 
-var (
+// ParamsKey saves the current module params.
-	// ParamsKey saves the current module params.
+var ParamsKey = collections.NewPrefix(0)
-	ParamsKey = collections.NewPrefix(0)
-)
 
 const (
 	ModuleName = "did"
@@ -25,3 +29,34 @@ var ORMModuleSchema = ormv1alpha1.ModuleSchemaDescriptor{
 	},
 	Prefix: []byte{0},
 }
+
+// VerifySignature verifies the signature of a message
+func VerifySignature(key []byte, msg []byte, sig []byte) bool {
+	pp, err := BuildEcPoint(key)
+	if err != nil {
+		return false
+	}
+	sigEd, err := ecdsa.DeserializeSecp256k1Signature(sig)
+	if err != nil {
+		return false
+	}
+	hash := sha3.New256()
+	_, err = hash.Write(msg)
+	if err != nil {
+		return false
+	}
+	digest := hash.Sum(nil)
+	return curves.VerifyEcdsa(pp, digest[:], sigEd)
+}
+
+// BuildEcPoint builds an elliptic curve point from a compressed byte slice
+func BuildEcPoint(pubKey []byte) (*curves.EcPoint, error) {
+	crv := curves.K256()
+	x := new(big.Int).SetBytes(pubKey[1:33])
+	y := new(big.Int).SetBytes(pubKey[33:])
+	ecCurve, err := crv.ToEllipticCurve()
+	if err != nil {
+		return nil, fmt.Errorf("error converting curve: %v", err)
+	}
+	return &curves.EcPoint{X: x, Y: y, Curve: ecCurve}, nil
+}

x/did/types/state.pb.go

@@ -547,49 +547,50 @@ func init() {
 func init() { proto.RegisterFile("did/v1/state.proto", fileDescriptor_f44bb702879c34b4) }
 
 var fileDescriptor_f44bb702879c34b4 = []byte{
-	// 672 bytes of a gzipped FileDescriptorProto
+	// 685 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xbf, 0x6e, 0x13, 0x4f,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x3f, 0x6f, 0x13, 0x4d,
-	0x10, 0xc7, 0x73, 0x3e, 0xff, 0x1d, 0xdb, 0x49, 0xb4, 0x8a, 0x7e, 0xbf, 0xc3, 0x08, 0x63, 0x8c,
+	0x10, 0xc6, 0x73, 0x3e, 0xff, 0x1d, 0xdb, 0x89, 0xb5, 0x8a, 0xf2, 0xde, 0x6b, 0xc0, 0x18, 0xa3,
-	0x22, 0x85, 0xc6, 0x47, 0xa0, 0x41, 0x09, 0x05, 0x26, 0x49, 0x01, 0x28, 0x12, 0x32, 0x54, 0x34,
+	0x48, 0xa1, 0xb1, 0x09, 0x34, 0x28, 0xa1, 0xc0, 0x24, 0x29, 0x00, 0x45, 0x42, 0x86, 0x8a, 0xc6,
-	0xd6, 0xfa, 0x76, 0x63, 0x2f, 0x3e, 0xef, 0x9e, 0x76, 0xd7, 0x4e, 0xae, 0xa3, 0x47, 0x42, 0x14,
+	0x5a, 0x7b, 0x37, 0xf6, 0xe2, 0xf3, 0xee, 0x69, 0x77, 0xed, 0xe4, 0x3a, 0x7a, 0x24, 0x44, 0x41,
-	0x34, 0x34, 0x79, 0x05, 0x5e, 0x83, 0x32, 0x12, 0x0d, 0x25, 0x4a, 0xde, 0x80, 0x27, 0x40, 0x77,
+	0x9d, 0x96, 0x92, 0xaf, 0x41, 0x19, 0x89, 0x86, 0x12, 0x25, 0xdf, 0x80, 0x4f, 0x80, 0xf6, 0xf6,
-	0x7b, 0x8e, 0x8f, 0x73, 0x00, 0x21, 0x3a, 0xef, 0x77, 0x76, 0x3c, 0x9f, 0xf9, 0xce, 0xdc, 0x02,
+	0x1c, 0x1f, 0x76, 0x00, 0x21, 0xba, 0xec, 0x33, 0x33, 0x99, 0xdf, 0x3c, 0x33, 0x3e, 0x40, 0x84,
-	0x22, 0x8c, 0xb8, 0xb3, 0x6d, 0x57, 0x69, 0xac, 0x69, 0x27, 0x90, 0x42, 0x0b, 0x54, 0x24, 0x8c,
+	0x91, 0xd6, 0x74, 0xbb, 0xa5, 0x34, 0xd6, 0xb4, 0x19, 0x48, 0xa1, 0x05, 0xca, 0x12, 0x46, 0x9a,
-	0x74, 0x66, 0xdb, 0x8d, 0xff, 0x3d, 0xa1, 0x26, 0x42, 0xb9, 0x42, 0x4e, 0xa2, 0x2b, 0x42, 0x4e,
+	0xd3, 0xed, 0xea, 0x7f, 0x7d, 0xa1, 0xc6, 0x42, 0xb5, 0x84, 0x1c, 0x9b, 0x14, 0x21, 0xc7, 0x36,
-	0xcc, 0x85, 0xc6, 0x46, 0x92, 0x34, 0xa4, 0x9c, 0x2a, 0xa6, 0x8c, 0xda, 0xfe, 0x68, 0x41, 0xa9,
+	0xa1, 0xba, 0x1e, 0x17, 0x0d, 0x28, 0xa7, 0x8a, 0x29, 0xab, 0x36, 0x3e, 0x3a, 0x90, 0x6b, 0xfb,
-	0xeb, 0x33, 0xac, 0xa8, 0x42, 0xab, 0x90, 0x63, 0xc4, 0xb1, 0x5a, 0xd6, 0x56, 0xa5, 0x97, 0x63,
+	0x0c, 0x2b, 0xaa, 0xd0, 0x2a, 0xa4, 0x18, 0xf1, 0x9c, 0xba, 0xb3, 0x55, 0xe8, 0xa4, 0x18, 0x41,
-	0x04, 0xfd, 0x07, 0x45, 0x21, 0xd9, 0x90, 0x71, 0x27, 0x17, 0x6b, 0xc9, 0x29, 0xd2, 0x47, 0x98,
+	0x1b, 0x90, 0x15, 0x92, 0x0d, 0x18, 0xf7, 0x52, 0x91, 0x16, 0xbf, 0x8c, 0x3e, 0xc4, 0x9c, 0xf8,
-	0x13, 0x9f, 0x3a, 0xb6, 0xd1, 0xcd, 0x09, 0x35, 0x01, 0x3c, 0xc1, 0xb5, 0x14, 0xbe, 0x4f, 0xa5,
+	0xd4, 0x73, 0xad, 0x6e, 0x5f, 0xa8, 0x06, 0xd0, 0x17, 0x5c, 0x4b, 0xe1, 0xfb, 0x54, 0x7a, 0xe9,
-	0x93, 0x8f, 0x63, 0x29, 0x25, 0x8a, 0xd3, 0x93, 0x80, 0x49, 0xac, 0x99, 0xe0, 0x4e, 0xa1, 0x65,
+	0x28, 0x96, 0x50, 0x4c, 0x9c, 0x9e, 0x04, 0x4c, 0x62, 0xcd, 0x04, 0xf7, 0x32, 0x75, 0x67, 0x2b,
-	0x6d, 0xe5, 0x7b, 0x29, 0x65, 0x67, 0xf5, 0xfb, 0xe9, 0x97, 0x77, 0x76, 0x19, 0xf2, 0x86, 0xa3,
+	0xdd, 0x49, 0x28, 0x3b, 0xd7, 0xbf, 0x9f, 0x7e, 0x79, 0xe7, 0x6e, 0x40, 0xda, 0x70, 0xa0, 0xd2,
-	0xfd, 0x26, 0x07, 0x95, 0xae, 0x52, 0x54, 0x46, 0xd1, 0x25, 0xba, 0x6b, 0x50, 0x1e, 0xd3, 0xb0,
+	0xac, 0x4b, 0xc5, 0xf1, 0x1c, 0xcf, 0x69, 0xbc, 0x49, 0x41, 0xa1, 0xad, 0x14, 0x95, 0x26, 0x77,
-	0xaf, 0xc3, 0x80, 0x26, 0x7c, 0xa5, 0x31, 0x0d, 0x5f, 0x86, 0x81, 0x01, 0x91, 0x94, 0x50, 0xae,
+	0x89, 0xf5, 0x7f, 0xc8, 0x8f, 0x68, 0xd8, 0xd5, 0x61, 0x40, 0x63, 0xda, 0xdc, 0x88, 0x86, 0x2f,
-	0x19, 0xf6, 0x63, 0xc8, 0x5a, 0x2f, 0xa5, 0xa0, 0x5d, 0x28, 0x4f, 0xa8, 0xc6, 0x04, 0x6b, 0xec,
+	0xc3, 0xc0, 0x62, 0x49, 0x4a, 0x28, 0xd7, 0x0c, 0xfb, 0x11, 0x72, 0xa9, 0x93, 0x50, 0xd0, 0x2e,
-	0xe4, 0x5b, 0xf6, 0x56, 0xf5, 0xde, 0xcd, 0x8e, 0xb1, 0xaf, 0x73, 0x59, 0xaf, 0x73, 0x98, 0xdc,
+	0xe4, 0xc7, 0x54, 0x63, 0x82, 0x35, 0xf6, 0xd2, 0x75, 0x77, 0xab, 0x78, 0xef, 0x66, 0xd3, 0x9a,
-	0x38, 0xe0, 0x5a, 0x86, 0xbd, 0xcb, 0x84, 0x4c, 0x97, 0x85, 0x6c, 0x97, 0x8d, 0x5d, 0xa8, 0xff,
+	0xd9, 0xbc, 0xec, 0xd7, 0x3c, 0x8c, 0x33, 0x0e, 0xb8, 0x96, 0x61, 0xe7, 0xb2, 0x60, 0x61, 0xe6,
-	0x94, 0x8a, 0xd6, 0xc1, 0x1e, 0xd3, 0x30, 0x21, 0x8f, 0x7e, 0xa2, 0x0d, 0x28, 0xcc, 0xb0, 0x3f,
+	0xcc, 0xe2, 0xcc, 0xd5, 0x5d, 0x28, 0xff, 0x54, 0x8a, 0x2a, 0xe0, 0x8e, 0x68, 0x18, 0x93, 0x9b,
-	0x9d, 0x73, 0x9b, 0xc3, 0x4e, 0xee, 0x81, 0x95, 0xb1, 0x20, 0xd7, 0xfe, 0x60, 0x41, 0xb5, 0xab,
+	0x3f, 0xd1, 0x3a, 0x64, 0xa6, 0xd8, 0x9f, 0xcc, 0xb8, 0xed, 0x63, 0x27, 0xf5, 0xc0, 0xd9, 0x59,
-	0x35, 0x8d, 0x26, 0xfd, 0x97, 0x26, 0x5c, 0x16, 0xb1, 0x53, 0x45, 0x22, 0x35, 0x90, 0x42, 0x1c,
+	0x8d, 0x0c, 0xc9, 0x5b, 0x43, 0xbc, 0x54, 0xe3, 0x83, 0x03, 0xc5, 0xb6, 0xd6, 0xd4, 0xec, 0xfd,
-	0x25, 0xe3, 0x31, 0x87, 0x3f, 0xf5, 0x94, 0xc1, 0xb2, 0xdb, 0x9f, 0x2c, 0x80, 0xbd, 0xc5, 0x60,
+	0x2f, 0x4d, 0xb8, 0x6c, 0xe2, 0x26, 0x9a, 0x18, 0x35, 0x90, 0x42, 0x1c, 0xc5, 0xcb, 0xb2, 0x8f,
-	0xb3, 0x54, 0xeb, 0x60, 0x93, 0x08, 0xdf, 0x74, 0x4c, 0x18, 0x41, 0x77, 0x61, 0x23, 0x98, 0x0e,
+	0x3f, 0xcd, 0xb4, 0x80, 0xe5, 0x36, 0x3e, 0x39, 0x00, 0x7b, 0xf3, 0x35, 0x2f, 0x52, 0x55, 0xc0,
-	0x7c, 0xe6, 0xf5, 0x23, 0xdc, 0xc9, 0xd4, 0xd7, 0x6c, 0x80, 0xd5, 0x9c, 0x0d, 0x99, 0xd8, 0x33,
+	0x25, 0x06, 0xdf, 0x4e, 0x4c, 0x18, 0x41, 0x77, 0x61, 0x3d, 0x98, 0xf4, 0x7c, 0xd6, 0xef, 0x1a,
-	0x1a, 0x1e, 0xce, 0x23, 0xe8, 0x3a, 0x54, 0x66, 0x78, 0xea, 0xeb, 0xbe, 0xc7, 0x48, 0x02, 0x5b,
+	0xdc, 0xf1, 0xc4, 0xd7, 0xac, 0x87, 0xd5, 0x8c, 0x0d, 0xd9, 0xd8, 0x33, 0x1a, 0x1e, 0xce, 0x22,
-	0x8e, 0x85, 0x3d, 0x46, 0x50, 0x0b, 0xaa, 0x47, 0x8c, 0x0f, 0xa9, 0x0c, 0x24, 0xe3, 0x3a, 0x06,
+	0xe8, 0x1a, 0x14, 0xa6, 0x78, 0xe2, 0xeb, 0x6e, 0x9f, 0x91, 0x18, 0x36, 0x1f, 0x09, 0x7b, 0x8c,
-	0xae, 0xf5, 0xd2, 0x52, 0x86, 0x38, 0xdf, 0x7e, 0x6b, 0x03, 0xec, 0x53, 0x9f, 0x0e, 0xaf, 0xf6,
+	0xa0, 0x3a, 0x14, 0x8f, 0x18, 0x1f, 0x50, 0x19, 0x48, 0xc6, 0x75, 0x04, 0x5c, 0xea, 0x24, 0xa5,
-	0x71, 0x99, 0xf8, 0x06, 0x80, 0x37, 0xc2, 0x8c, 0x1b, 0x6f, 0x0d, 0x67, 0x25, 0x56, 0x62, 0x77,
+	0x05, 0xe2, 0x74, 0xe3, 0xad, 0x0b, 0xb0, 0x4f, 0x7d, 0x3a, 0xb8, 0xda, 0xc7, 0x65, 0xe2, 0x1b,
-	0x6f, 0x43, 0xdd, 0x84, 0x31, 0x21, 0x92, 0x2a, 0x95, 0x20, 0xd6, 0x62, 0xb1, 0x6b, 0x34, 0xb4,
+	0x00, 0xfd, 0x21, 0x66, 0xdc, 0x7a, 0x6b, 0x39, 0x0b, 0x91, 0x12, 0xb9, 0x7b, 0x1b, 0xca, 0x36,
-	0x09, 0xab, 0x0b, 0x13, 0xfb, 0x51, 0x01, 0x63, 0x6d, 0x7d, 0xa1, 0xee, 0xff, 0xc6, 0x9c, 0xe2,
+	0x8c, 0x09, 0x91, 0x54, 0xa9, 0x18, 0xb1, 0x14, 0x89, 0x6d, 0xab, 0xa1, 0x4d, 0x58, 0x9d, 0x9b,
-	0x2f, 0xcd, 0x39, 0x84, 0xb5, 0x54, 0xc6, 0xeb, 0xe3, 0xb1, 0x72, 0x4a, 0xf1, 0x1e, 0x6f, 0xce,
+	0xd8, 0x35, 0x0d, 0xac, 0xb5, 0xe5, 0xb9, 0xba, 0xff, 0x1b, 0x73, 0xb2, 0xbf, 0x34, 0xe7, 0x10,
-	0xf7, 0x78, 0xd1, 0x6b, 0xe7, 0xf9, 0x3c, 0xff, 0xe9, 0xf1, 0x58, 0x99, 0x6d, 0xae, 0x07, 0x69,
+	0xd6, 0x12, 0x15, 0xaf, 0x8f, 0x47, 0xca, 0xcb, 0x45, 0x77, 0xbc, 0x39, 0xbb, 0xe3, 0xf9, 0xac,
-	0x2d, 0xe9, 0x95, 0x73, 0xea, 0xf7, 0x19, 0x71, 0xca, 0xf1, 0x87, 0x59, 0x49, 0x94, 0x27, 0xa4,
+	0xcd, 0xe7, 0xb3, 0xfa, 0xa7, 0xc7, 0x23, 0x65, 0xaf, 0xb9, 0x1c, 0x24, 0xb5, 0x78, 0x56, 0xce,
-	0xf1, 0x08, 0xd0, 0xf2, 0x7f, 0xfc, 0xc3, 0x5a, 0x17, 0xda, 0xa7, 0x16, 0x94, 0x5e, 0x50, 0x39,
+	0xa9, 0xdf, 0x65, 0xc4, 0xcb, 0x47, 0x3f, 0xd3, 0x42, 0xac, 0x3c, 0x21, 0xd5, 0x47, 0x80, 0x96,
-	0x63, 0x1e, 0x5d, 0x1a, 0xc5, 0x2d, 0xa8, 0x29, 0x13, 0x4a, 0xaf, 0x75, 0x35, 0xd1, 0x62, 0xf3,
+	0xff, 0xc7, 0x3f, 0x9c, 0x75, 0xa6, 0x71, 0xea, 0x40, 0xee, 0x05, 0x95, 0x53, 0xd6, 0xa7, 0x4b,
-	0xef, 0xc0, 0xfa, 0xfc, 0x0a, 0xe5, 0x24, 0x10, 0xd1, 0x0e, 0x98, 0x09, 0xad, 0x25, 0xfa, 0x41,
+	0xab, 0xb8, 0x05, 0x25, 0x65, 0x43, 0xc9, 0xb3, 0x2e, 0xc6, 0x5a, 0x64, 0xfe, 0x1d, 0xa8, 0xcc,
-	0x22, 0x5f, 0x31, 0x82, 0xfc, 0x15, 0x23, 0xc8, 0x00, 0x16, 0x1f, 0x3f, 0xfc, 0x7c, 0xde, 0xb4,
+	0x52, 0x28, 0x27, 0x81, 0x30, 0x37, 0x60, 0x37, 0xb4, 0x16, 0xeb, 0x07, 0xb1, 0x7c, 0xc5, 0x0a,
-	0xce, 0xce, 0x9b, 0xd6, 0xb7, 0xf3, 0xa6, 0xf5, 0xfe, 0xa2, 0xb9, 0x72, 0x76, 0xd1, 0x5c, 0xf9,
+	0xd2, 0x57, 0xac, 0x60, 0x01, 0x30, 0xfb, 0xf8, 0xe1, 0xe7, 0xf3, 0x9a, 0x73, 0x76, 0x5e, 0x73,
-	0x7a, 0xd1, 0x5c, 0x79, 0xd5, 0x1e, 0x32, 0x3d, 0x9a, 0x0e, 0x3a, 0x9e, 0x98, 0xb8, 0x82, 0x2b,
+	0xbe, 0x9d, 0xd7, 0x9c, 0xf7, 0x17, 0xb5, 0x95, 0xb3, 0x8b, 0xda, 0xca, 0xd7, 0x8b, 0xda, 0xca,
-	0xc1, 0xa5, 0x3b, 0x3a, 0xc6, 0xa1, 0x7b, 0xe2, 0x46, 0xef, 0x6b, 0x44, 0xac, 0x06, 0xc5, 0xf8,
+	0xab, 0xc6, 0x80, 0xe9, 0xe1, 0xa4, 0xd7, 0xec, 0x8b, 0x71, 0x4b, 0x70, 0x25, 0xb8, 0x6c, 0x0d,
-	0x6d, 0xbd, 0xff, 0x23, 0x00, 0x00, 0xff, 0xff, 0x5d, 0x24, 0xdd, 0x73, 0xa8, 0x05, 0x00, 0x00,
+	0x8f, 0x71, 0xd8, 0x3a, 0x69, 0x99, 0xaf, 0xad, 0x21, 0x56, 0xbd, 0x6c, 0xf4, 0xa5, 0xbd, 0xff,
+	0x23, 0x00, 0x00, 0xff, 0xff, 0x12, 0x6f, 0x94, 0xba, 0xb6, 0x05, 0x00, 0x00,
 }
 
 func (m *Aliases) Marshal() (dAtA []byte, err error) {

x/did/types/tx.pb.go

@@ -370,40 +370,40 @@ func init() {
 func init() { proto.RegisterFile("did/v1/tx.proto", fileDescriptor_d73284df019ff211) }
 
 var fileDescriptor_d73284df019ff211 = []byte{
-	// 519 bytes of a gzipped FileDescriptorProto
+	// 525 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0x4f, 0x6b, 0x53, 0x4f,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xc1, 0x6b, 0x13, 0x4f,
-	0x14, 0xcd, 0x24, 0xf9, 0xe5, 0x47, 0xae, 0xb5, 0x85, 0x47, 0x68, 0x5e, 0x1e, 0xf2, 0xd2, 0x46,
+	0x14, 0xce, 0x26, 0xf9, 0xe5, 0x47, 0x9e, 0xb5, 0x85, 0xa1, 0x34, 0x9b, 0x45, 0x36, 0x6d, 0x14,
-	0xc1, 0x58, 0x34, 0x8f, 0x46, 0x10, 0x11, 0x37, 0x8d, 0x1b, 0x5d, 0x04, 0x24, 0xe2, 0x46, 0x17,
+	0x8c, 0x45, 0xb3, 0x34, 0x82, 0x88, 0x78, 0x69, 0xbc, 0xe8, 0x21, 0x20, 0x2b, 0x5e, 0x14, 0x94,
-	0x3a, 0xcd, 0x9b, 0x4e, 0x06, 0x93, 0x99, 0x30, 0x77, 0x12, 0x1b, 0x57, 0xe2, 0xc6, 0xad, 0x1f,
+	0x69, 0x76, 0x3a, 0x19, 0x4c, 0x66, 0xc2, 0xbc, 0x49, 0x6c, 0x3c, 0x89, 0x17, 0xaf, 0xfe, 0x05,
-	0xc1, 0x8f, 0xd0, 0x85, 0x5f, 0x41, 0xe8, 0xb2, 0xb8, 0x72, 0x25, 0x92, 0x2c, 0x8a, 0xdf, 0x42,
+	0xfe, 0x0d, 0x3d, 0xf8, 0x2f, 0x08, 0x3d, 0x16, 0x4f, 0x9e, 0x44, 0x92, 0x43, 0xf1, 0xbf, 0x90,
-	0xde, 0xbf, 0xfc, 0x69, 0x13, 0x22, 0xe2, 0x6e, 0xe6, 0x9e, 0x73, 0xee, 0x9c, 0x33, 0x73, 0x19,
+	0xdd, 0xcd, 0x26, 0x9b, 0xb6, 0x21, 0x22, 0xde, 0x76, 0xde, 0xf7, 0xbd, 0x6f, 0xbf, 0xef, 0xcd,
-	0xd8, 0xf2, 0x85, 0xef, 0x0d, 0xf7, 0x3d, 0x73, 0x5c, 0xeb, 0x6b, 0x65, 0x94, 0x95, 0xf3, 0x85,
+	0x63, 0x60, 0x23, 0x10, 0x81, 0x37, 0xdc, 0xf3, 0xcc, 0x51, 0xbd, 0xaf, 0x95, 0x51, 0xa4, 0x10,
-	0x5f, 0x1b, 0xee, 0x3b, 0xc5, 0xb6, 0xc2, 0x9e, 0x42, 0xaf, 0x87, 0x3c, 0xc0, 0x7b, 0xc8, 0x23,
+	0x88, 0xa0, 0x3e, 0xdc, 0x73, 0x4a, 0x6d, 0x85, 0x3d, 0x85, 0x5e, 0x0f, 0x79, 0x88, 0xf7, 0x90,
-	0x82, 0x53, 0x88, 0x15, 0x9c, 0x49, 0x86, 0x02, 0x93, 0x2a, 0x57, 0x5c, 0x85, 0x4b, 0x2f, 0x58,
+	0xc7, 0x04, 0x67, 0x73, 0xda, 0xc1, 0x99, 0x64, 0x28, 0x30, 0xa9, 0x72, 0xc5, 0x55, 0xf4, 0xe9,
-	0xc5, 0xd5, 0x52, 0xd4, 0xe4, 0x55, 0x04, 0x44, 0x9b, 0x08, 0xaa, 0x7c, 0x24, 0xb0, 0xd5, 0x44,
+	0x85, 0x5f, 0xd3, 0x6a, 0x39, 0x16, 0x79, 0x1d, 0x03, 0xf1, 0x21, 0x86, 0xaa, 0x1f, 0x2d, 0xd8,
-	0xfe, 0xbc, 0xef, 0x53, 0xc3, 0x9e, 0x52, 0x4d, 0x7b, 0x68, 0xdd, 0x83, 0x3c, 0x1d, 0x98, 0x8e,
+	0x68, 0x21, 0x7f, 0xde, 0x0f, 0xa8, 0x61, 0x4f, 0xa9, 0xa6, 0x3d, 0x24, 0xf7, 0xa0, 0x48, 0x07,
-	0xd2, 0xc2, 0x8c, 0x6c, 0xb2, 0x43, 0xaa, 0xf9, 0x86, 0xfd, 0xed, 0xcb, 0x9d, 0x42, 0x2c, 0x3c,
+	0xa6, 0xa3, 0xb4, 0x30, 0x23, 0xdb, 0xda, 0xb6, 0x6a, 0xc5, 0xa6, 0xfd, 0xed, 0xcb, 0x9d, 0xcd,
-	0xf0, 0x7d, 0xcd, 0x10, 0x9f, 0x19, 0x2d, 0x24, 0x6f, 0xcd, 0xa8, 0xd6, 0x6d, 0xc8, 0xf5, 0xc3,
+	0x69, 0xe3, 0x7e, 0x10, 0x68, 0x86, 0xf8, 0xcc, 0x68, 0x21, 0xb9, 0x3f, 0xa7, 0x92, 0xdb, 0x50,
-	0x0e, 0x76, 0x7a, 0x87, 0x54, 0xaf, 0xd4, 0x37, 0x6b, 0x51, 0x88, 0x5a, 0xd4, 0xb7, 0x91, 0x3d,
+	0xe8, 0x47, 0x0a, 0x76, 0x76, 0xdb, 0xaa, 0x5d, 0x69, 0xac, 0xd7, 0xe3, 0x10, 0xf5, 0x58, 0xb7,
-	0xfd, 0x51, 0x4e, 0xb5, 0x62, 0xce, 0x83, 0xcd, 0x0f, 0xe7, 0x27, 0x7b, 0x33, 0x75, 0xa5, 0x04,
+	0x99, 0x3f, 0xf9, 0x51, 0xc9, 0xf8, 0x53, 0xce, 0x83, 0xf5, 0x0f, 0x67, 0xc7, 0xbb, 0xf3, 0xee,
-	0xc5, 0x0b, 0x46, 0x5a, 0x0c, 0xfb, 0x4a, 0x22, 0xab, 0x7c, 0x25, 0x21, 0xf6, 0x44, 0x0a, 0x23,
+	0x6a, 0x19, 0x4a, 0xe7, 0x8c, 0xf8, 0x0c, 0xfb, 0x4a, 0x22, 0xab, 0x7e, 0xb5, 0x22, 0xec, 0x89,
-	0x68, 0x57, 0xbc, 0x63, 0x8f, 0x94, 0x34, 0x5a, 0x75, 0xbb, 0x4c, 0xff, 0xb5, 0x59, 0x17, 0x80,
+	0x14, 0x46, 0xd0, 0xae, 0x78, 0xc7, 0x1e, 0x29, 0x69, 0xb4, 0xea, 0x76, 0x99, 0xfe, 0x6b, 0xb3,
-	0x22, 0x32, 0x6d, 0x84, 0x92, 0x81, 0xe1, 0x4c, 0x75, 0xa3, 0x35, 0x57, 0xb1, 0xae, 0x41, 0xfe,
+	0x2e, 0x00, 0x45, 0x64, 0xda, 0x08, 0x25, 0x43, 0xc3, 0xb9, 0xda, 0x9a, 0x9f, 0xaa, 0x90, 0x6b,
-	0x0d, 0x1b, 0x61, 0x87, 0x6a, 0x86, 0x76, 0x26, 0x84, 0x67, 0x05, 0xeb, 0x06, 0x5c, 0x1d, 0x32,
+	0x50, 0x7c, 0xc3, 0x46, 0xd8, 0xa1, 0x9a, 0xa1, 0x9d, 0x8b, 0xe0, 0x79, 0x81, 0xdc, 0x80, 0xab,
-	0x2d, 0x8e, 0x44, 0x9b, 0x46, 0x0d, 0xb2, 0x21, 0x63, 0xb1, 0x78, 0x29, 0xe2, 0x4b, 0x28, 0xaf,
+	0x43, 0xa6, 0xc5, 0xa1, 0x68, 0xd3, 0x58, 0x20, 0x1f, 0x31, 0x16, 0x8b, 0x17, 0x22, 0xbe, 0x84,
-	0x88, 0x91, 0x44, 0xb5, 0xee, 0x03, 0xb4, 0xa7, 0xd5, 0xb5, 0x79, 0xe6, 0xb8, 0x95, 0x5f, 0x04,
+	0xca, 0x92, 0x18, 0x49, 0x54, 0x72, 0x1f, 0xa0, 0x3d, 0xab, 0xae, 0xcc, 0x93, 0xe2, 0x56, 0x7f,
-	0x4a, 0x4d, 0xe4, 0x07, 0x03, 0xd3, 0x61, 0xd2, 0x04, 0x1e, 0xfe, 0xc5, 0x35, 0x2d, 0xfa, 0x49,
+	0x59, 0x50, 0x6e, 0x21, 0xdf, 0x1f, 0x98, 0x0e, 0x93, 0x26, 0xf4, 0xf0, 0x2f, 0xc6, 0xb4, 0xe8,
-	0xff, 0xb9, 0x1f, 0xab, 0x0e, 0xff, 0xd3, 0x08, 0xb4, 0x33, 0x6b, 0x64, 0x09, 0xd1, 0xda, 0x86,
+	0x27, 0xfb, 0xe7, 0x7e, 0x48, 0x03, 0xfe, 0xa7, 0x31, 0x68, 0xe7, 0x56, 0xb4, 0x25, 0x44, 0xb2,
-	0x9c, 0xd2, 0x82, 0x0b, 0x69, 0x67, 0x03, 0x49, 0x2b, 0xde, 0x5d, 0xba, 0xc8, 0xeb, 0xb0, 0xbb,
+	0x05, 0x05, 0xa5, 0x05, 0x17, 0xd2, 0xce, 0x87, 0x2d, 0xfe, 0xf4, 0x74, 0x61, 0x90, 0xd7, 0x61,
-	0x32, 0x6a, 0x72, 0x95, 0xf5, 0xcf, 0x69, 0xc8, 0x34, 0x91, 0x5b, 0x8f, 0x61, 0x63, 0x61, 0xbc,
+	0x67, 0x69, 0xd4, 0x64, 0x94, 0x8d, 0xcf, 0x59, 0xc8, 0xb5, 0x90, 0x93, 0xc7, 0xb0, 0xb6, 0xb0,
-	0x8b, 0xc9, 0x58, 0x5e, 0x18, 0x37, 0xa7, 0xbc, 0x02, 0x98, 0x3e, 0xce, 0x6b, 0x28, 0x2c, 0x9d,
+	0xde, 0xa5, 0x64, 0x2d, 0xcf, 0xad, 0x9b, 0x53, 0x59, 0x02, 0xcc, 0x2e, 0xe7, 0x15, 0x10, 0x9f,
-	0xc1, 0x79, 0xe1, 0x32, 0x82, 0x73, 0x73, 0x0d, 0x61, 0x7a, 0xc2, 0x11, 0x6c, 0xaf, 0x78, 0xc0,
+	0x71, 0x81, 0x86, 0xe9, 0xd4, 0x68, 0xd3, 0x6d, 0x97, 0xdd, 0xad, 0x73, 0x73, 0x05, 0x61, 0xa6,
-	0xdd, 0xb9, 0x16, 0xcb, 0x29, 0xce, 0xad, 0xb5, 0x94, 0xe4, 0x1c, 0xe7, 0xbf, 0xf7, 0xe7, 0x27,
+	0x7f, 0x08, 0x5b, 0x4b, 0xae, 0x6f, 0x27, 0x25, 0x71, 0x39, 0xc5, 0xb9, 0xb5, 0x92, 0x92, 0xfc,
-	0x7b, 0xa4, 0xf1, 0xf0, 0x74, 0xec, 0x92, 0xb3, 0xb1, 0x4b, 0x7e, 0x8e, 0x5d, 0xf2, 0x69, 0xe2,
+	0xc7, 0xf9, 0xef, 0xfd, 0xd9, 0xf1, 0xae, 0xd5, 0x7c, 0x78, 0x32, 0x76, 0xad, 0xd3, 0xb1, 0x6b,
-	0xa6, 0xce, 0x26, 0x6e, 0xea, 0xfb, 0xc4, 0x4d, 0xbd, 0xa8, 0x70, 0x61, 0x3a, 0x83, 0xc3, 0x5a,
+	0xfd, 0x1c, 0xbb, 0xd6, 0xa7, 0x89, 0x9b, 0x39, 0x9d, 0xb8, 0x99, 0xef, 0x13, 0x37, 0xf3, 0xa2,
-	0x5b, 0xf5, 0x3c, 0x25, 0x51, 0x49, 0xed, 0x75, 0xde, 0xd2, 0x91, 0x77, 0xec, 0x05, 0xff, 0x8e,
+	0xca, 0x85, 0xe9, 0x0c, 0x0e, 0xea, 0x6d, 0xd5, 0xf3, 0x94, 0x44, 0x25, 0xb5, 0xd7, 0x79, 0x4b,
-	0x19, 0xf5, 0x19, 0x1e, 0xe6, 0xc2, 0x2f, 0xe4, 0xee, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x57,
+	0x47, 0xde, 0x91, 0x17, 0xbe, 0x3a, 0x66, 0xd4, 0x67, 0x78, 0x50, 0x88, 0x1e, 0x90, 0xbb, 0xbf,
-	0x4f, 0xb3, 0x3a, 0xbd, 0x04, 0x00, 0x00,
+	0x03, 0x00, 0x00, 0xff, 0xff, 0x74, 0x50, 0x71, 0x32, 0xbb, 0x04, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -422,8 +422,8 @@ type MsgClient interface {
 	//
 	// Since: cosmos-sdk 0.47
 	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
-	// InitializeController initializes a controller with the given assertions, keyshares, and verifications.
+	// RegisterController initializes a controller with the given authentication set, address, cid, publicKey, and user-defined alias.
-	InitializeController(ctx context.Context, in *MsgInitializeController, opts ...grpc.CallOption) (*MsgInitializeControllerResponse, error)
+	RegisterController(ctx context.Context, in *MsgInitializeController, opts ...grpc.CallOption) (*MsgInitializeControllerResponse, error)
 	// AuthenticateController asserts the given controller is the owner of the given address.
 	AuthenticateController(ctx context.Context, in *MsgAuthenticateController, opts ...grpc.CallOption) (*MsgAuthenticateControllerResponse, error)
 }
@@ -445,9 +445,9 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts
 	return out, nil
 }
 
-func (c *msgClient) InitializeController(ctx context.Context, in *MsgInitializeController, opts ...grpc.CallOption) (*MsgInitializeControllerResponse, error) {
+func (c *msgClient) RegisterController(ctx context.Context, in *MsgInitializeController, opts ...grpc.CallOption) (*MsgInitializeControllerResponse, error) {
 	out := new(MsgInitializeControllerResponse)
-	err := c.cc.Invoke(ctx, "/did.v1.Msg/InitializeController", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/did.v1.Msg/RegisterController", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -469,8 +469,8 @@ type MsgServer interface {
 	//
 	// Since: cosmos-sdk 0.47
 	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
-	// InitializeController initializes a controller with the given assertions, keyshares, and verifications.
+	// RegisterController initializes a controller with the given authentication set, address, cid, publicKey, and user-defined alias.
-	InitializeController(context.Context, *MsgInitializeController) (*MsgInitializeControllerResponse, error)
+	RegisterController(context.Context, *MsgInitializeController) (*MsgInitializeControllerResponse, error)
 	// AuthenticateController asserts the given controller is the owner of the given address.
 	AuthenticateController(context.Context, *MsgAuthenticateController) (*MsgAuthenticateControllerResponse, error)
 }
@@ -482,8 +482,8 @@ type UnimplementedMsgServer struct {
 func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
 }
-func (*UnimplementedMsgServer) InitializeController(ctx context.Context, req *MsgInitializeController) (*MsgInitializeControllerResponse, error) {
+func (*UnimplementedMsgServer) RegisterController(ctx context.Context, req *MsgInitializeController) (*MsgInitializeControllerResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method InitializeController not implemented")
+	return nil, status.Errorf(codes.Unimplemented, "method RegisterController not implemented")
 }
 func (*UnimplementedMsgServer) AuthenticateController(ctx context.Context, req *MsgAuthenticateController) (*MsgAuthenticateControllerResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method AuthenticateController not implemented")
@@ -511,20 +511,20 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_InitializeController_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _Msg_RegisterController_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgInitializeController)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).InitializeController(ctx, in)
+		return srv.(MsgServer).RegisterController(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/did.v1.Msg/InitializeController",
+		FullMethod: "/did.v1.Msg/RegisterController",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).InitializeController(ctx, req.(*MsgInitializeController))
+		return srv.(MsgServer).RegisterController(ctx, req.(*MsgInitializeController))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -556,8 +556,8 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Msg_UpdateParams_Handler,
 		},
 		{
-			MethodName: "InitializeController",
+			MethodName: "RegisterController",
-			Handler:    _Msg_InitializeController_Handler,
+			Handler:    _Msg_RegisterController_Handler,
 		},
 		{
 			MethodName: "AuthenticateController",

x/did/types/types.pb.go

@@ -1,11 +1,12 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: did/v1/account.proto
+// source: did/v1/types.proto
 
 package types
 
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/cosmos-proto"
+	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
 	_ "github.com/cosmos/gogoproto/gogoproto"
 	proto "github.com/cosmos/gogoproto/proto"
 	io "io"
@@ -24,8 +25,8 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
-// DIDDocument defines a DID document
+// BaseDocument defines a DID document
-type DIDDocument struct {
+type BaseDocument struct {
 	Id                   string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
 	VerificationMethods  []*VerificationMethod `protobuf:"bytes,2,rep,name=verification_methods,json=verificationMethods,proto3" json:"verification_methods,omitempty"`
 	Authentication       []string              `protobuf:"bytes,4,rep,name=authentication,proto3" json:"authentication,omitempty"`
@@ -34,18 +35,18 @@ type DIDDocument struct {
 	CapabilityInvocation []string              `protobuf:"bytes,8,rep,name=capability_invocation,json=capabilityInvocation,proto3" json:"capability_invocation,omitempty"`
 }
 
-func (m *DIDDocument) Reset()         { *m = DIDDocument{} }
+func (m *BaseDocument) Reset()         { *m = BaseDocument{} }
-func (m *DIDDocument) String() string { return proto.CompactTextString(m) }
+func (m *BaseDocument) String() string { return proto.CompactTextString(m) }
-func (*DIDDocument) ProtoMessage()    {}
+func (*BaseDocument) ProtoMessage()    {}
-func (*DIDDocument) Descriptor() ([]byte, []int) {
+func (*BaseDocument) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1c7ebf7d0ca3c72, []int{0}
+	return fileDescriptor_e3176cd2dbe76ac1, []int{0}
 }
-func (m *DIDDocument) XXX_Unmarshal(b []byte) error {
+func (m *BaseDocument) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *DIDDocument) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *BaseDocument) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_DIDDocument.Marshal(b, m, deterministic)
+		return xxx_messageInfo_BaseDocument.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -55,54 +56,54 @@ func (m *DIDDocument) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
-func (m *DIDDocument) XXX_Merge(src proto.Message) {
+func (m *BaseDocument) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DIDDocument.Merge(m, src)
+	xxx_messageInfo_BaseDocument.Merge(m, src)
 }
-func (m *DIDDocument) XXX_Size() int {
+func (m *BaseDocument) XXX_Size() int {
 	return m.Size()
 }
-func (m *DIDDocument) XXX_DiscardUnknown() {
+func (m *BaseDocument) XXX_DiscardUnknown() {
-	xxx_messageInfo_DIDDocument.DiscardUnknown(m)
+	xxx_messageInfo_BaseDocument.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_DIDDocument proto.InternalMessageInfo
+var xxx_messageInfo_BaseDocument proto.InternalMessageInfo
 
-func (m *DIDDocument) GetId() string {
+func (m *BaseDocument) GetId() string {
 	if m != nil {
 		return m.Id
 	}
 	return ""
 }
 
-func (m *DIDDocument) GetVerificationMethods() []*VerificationMethod {
+func (m *BaseDocument) GetVerificationMethods() []*VerificationMethod {
 	if m != nil {
 		return m.VerificationMethods
 	}
 	return nil
 }
 
-func (m *DIDDocument) GetAuthentication() []string {
+func (m *BaseDocument) GetAuthentication() []string {
 	if m != nil {
 		return m.Authentication
 	}
 	return nil
 }
 
-func (m *DIDDocument) GetAssertionMethod() []string {
+func (m *BaseDocument) GetAssertionMethod() []string {
 	if m != nil {
 		return m.AssertionMethod
 	}
 	return nil
 }
 
-func (m *DIDDocument) GetCapabilityDelegation() []string {
+func (m *BaseDocument) GetCapabilityDelegation() []string {
 	if m != nil {
 		return m.CapabilityDelegation
 	}
 	return nil
 }
 
-func (m *DIDDocument) GetCapabilityInvocation() []string {
+func (m *BaseDocument) GetCapabilityInvocation() []string {
 	if m != nil {
 		return m.CapabilityInvocation
 	}
@@ -123,7 +124,7 @@ func (m *VerificationMethod) Reset()         { *m = VerificationMethod{} }
 func (m *VerificationMethod) String() string { return proto.CompactTextString(m) }
 func (*VerificationMethod) ProtoMessage()    {}
 func (*VerificationMethod) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1c7ebf7d0ca3c72, []int{1}
+	return fileDescriptor_e3176cd2dbe76ac1, []int{1}
 }
 func (m *VerificationMethod) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -181,46 +182,47 @@ func (m *VerificationMethod) GetPublicKeyJwks() map[string]string {
 }
 
 func init() {
-	proto.RegisterType((*DIDDocument)(nil), "did.v1.DIDDocument")
+	proto.RegisterType((*BaseDocument)(nil), "did.v1.BaseDocument")
 	proto.RegisterType((*VerificationMethod)(nil), "did.v1.VerificationMethod")
 	proto.RegisterMapType((map[string]string)(nil), "did.v1.VerificationMethod.PublicKeyJwksEntry")
 }
 
-func init() { proto.RegisterFile("did/v1/account.proto", fileDescriptor_f1c7ebf7d0ca3c72) }
+func init() { proto.RegisterFile("did/v1/types.proto", fileDescriptor_e3176cd2dbe76ac1) }
 
-var fileDescriptor_f1c7ebf7d0ca3c72 = []byte{
+var fileDescriptor_e3176cd2dbe76ac1 = []byte{
-	// 440 bytes of a gzipped FileDescriptorProto
+	// 449 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xb1, 0x8e, 0xd3, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xc1, 0x6e, 0xd3, 0x40,
-	0x10, 0x86, 0x63, 0x87, 0x3b, 0xb8, 0x8d, 0xb8, 0x3b, 0x2d, 0x46, 0x32, 0x29, 0xac, 0x28, 0x05,
+	0x10, 0x86, 0x63, 0x87, 0x16, 0xba, 0x85, 0xb6, 0x5a, 0x8c, 0x30, 0x39, 0x58, 0x51, 0x0e, 0x28,
-	0x0a, 0x05, 0x36, 0x77, 0xd7, 0x20, 0x44, 0x81, 0x50, 0x28, 0x0e, 0x14, 0x09, 0x45, 0x82, 0x82,
+	0x1c, 0xb0, 0x69, 0x7b, 0x41, 0x88, 0x03, 0xaa, 0xca, 0x01, 0x50, 0x24, 0x14, 0x09, 0x0e, 0x5c,
-	0xc6, 0x5a, 0xaf, 0x07, 0x67, 0x89, 0xbd, 0x63, 0x79, 0xd7, 0x0e, 0x7e, 0x0a, 0x78, 0x0d, 0xde,
+	0xac, 0xb5, 0x3d, 0x38, 0x4b, 0xec, 0x5d, 0xcb, 0xb3, 0x76, 0xf0, 0x53, 0xc0, 0x73, 0xf0, 0x24,
-	0x84, 0x32, 0x25, 0x25, 0x4a, 0x5e, 0x04, 0xc5, 0x76, 0x82, 0x15, 0xeb, 0xba, 0xdd, 0xef, 0xff,
+	0x1c, 0x7b, 0xe4, 0x88, 0x92, 0x17, 0x41, 0xd9, 0x75, 0x82, 0x95, 0xa8, 0xb7, 0xd9, 0xff, 0xff,
-	0xe7, 0xdf, 0x9d, 0xd1, 0x10, 0x2b, 0x14, 0xa1, 0x57, 0x5c, 0x79, 0x8c, 0x73, 0xcc, 0xa5, 0x76,
+	0x66, 0x76, 0x66, 0x34, 0x84, 0x26, 0x3c, 0x09, 0xea, 0xf3, 0x40, 0x35, 0x05, 0xa0, 0x5f, 0x94,
-	0xd3, 0x0c, 0x35, 0xd2, 0xd3, 0x50, 0x84, 0x6e, 0x71, 0x35, 0x7c, 0xc2, 0x51, 0x25, 0xa8, 0xfc,
+	0x52, 0x49, 0x7a, 0x98, 0xf0, 0xc4, 0xaf, 0xcf, 0x07, 0x8f, 0x63, 0x89, 0xb9, 0xc4, 0x20, 0xc7,
-	0x8a, 0x7a, 0xf5, 0xa5, 0xb6, 0x0c, 0xad, 0x08, 0x23, 0xac, 0xf9, 0xee, 0xb4, 0xa7, 0x4d, 0x5c,
+	0x74, 0x8d, 0xe4, 0x98, 0x1a, 0x60, 0xe0, 0xb4, 0x49, 0x29, 0x08, 0x40, 0x8e, 0x1b, 0x35, 0x95,
-	0x04, 0x12, 0x94, 0x68, 0xbc, 0xe3, 0x5f, 0x26, 0x19, 0x4c, 0x6f, 0xa7, 0x53, 0xe4, 0x79, 0x02,
+	0xa9, 0xd4, 0x61, 0xb0, 0x8e, 0x5a, 0xf5, 0x89, 0x29, 0x12, 0x1a, 0xc3, 0x3c, 0x8c, 0x35, 0xfa,
-	0x52, 0xd3, 0x73, 0x62, 0x8a, 0xd0, 0x36, 0x46, 0xc6, 0xe4, 0x6c, 0x6e, 0x8a, 0x90, 0xce, 0x88,
+	0x65, 0x93, 0xfb, 0x57, 0x0c, 0xe1, 0x5a, 0xc6, 0x55, 0x0e, 0x42, 0xd1, 0x13, 0x62, 0xf3, 0xc4,
-	0x55, 0x40, 0x26, 0xbe, 0x0a, 0xce, 0xb4, 0x40, 0xe9, 0x27, 0xa0, 0x17, 0x18, 0x2a, 0xdb, 0x1c,
+	0xb5, 0x86, 0xd6, 0xf8, 0x68, 0x6a, 0xf3, 0x84, 0x4e, 0x88, 0x53, 0x43, 0xc9, 0xbf, 0xf2, 0x98,
-	0xf5, 0x27, 0x83, 0xeb, 0xa1, 0x5b, 0xff, 0xc6, 0xfd, 0xdc, 0xf2, 0xcc, 0x2a, 0xcb, 0xfc, 0x51,
+	0x29, 0x2e, 0x45, 0x98, 0x83, 0x9a, 0xc9, 0x04, 0x5d, 0x7b, 0xd8, 0x1f, 0x1f, 0x5f, 0x0c, 0x7c,
-	0xd1, 0x61, 0x8a, 0x3e, 0x25, 0xe7, 0x2c, 0xd7, 0x0b, 0x90, 0xba, 0x11, 0xec, 0x7b, 0xa3, 0xfe,
+	0xd3, 0xa7, 0xff, 0xb9, 0xc3, 0x4c, 0x34, 0x32, 0x7d, 0x58, 0xef, 0x69, 0x48, 0x9f, 0x92, 0x13,
-	0xe4, 0x6c, 0x7e, 0x44, 0xe9, 0x33, 0x72, 0xc9, 0x94, 0x82, 0xac, 0xf5, 0xa6, 0x7d, 0x52, 0x39,
+	0x56, 0xa9, 0x19, 0x08, 0xd5, 0x1a, 0xee, 0x9d, 0x61, 0x7f, 0x7c, 0x34, 0xdd, 0x51, 0xe9, 0x33,
-	0x2f, 0x0e, 0xbc, 0xce, 0xa4, 0x37, 0xe4, 0x31, 0x67, 0x29, 0x0b, 0x44, 0x2c, 0x74, 0xe9, 0x87,
+	0x72, 0xc6, 0x10, 0xa1, 0xec, 0xfc, 0xe9, 0x1e, 0x68, 0xf2, 0x74, 0xab, 0x9b, 0x9a, 0xf4, 0x92,
-	0x10, 0x43, 0x54, 0x27, 0xdf, 0xaf, 0xfc, 0xd6, 0x7f, 0x71, 0x7a, 0xd0, 0x8e, 0x8a, 0x84, 0x2c,
+	0x3c, 0x8a, 0x59, 0xc1, 0x22, 0x9e, 0x71, 0xd5, 0x84, 0x09, 0x64, 0x90, 0x9a, 0xca, 0x77, 0x35,
-	0xb0, 0xf9, 0xce, 0x83, 0xe3, 0xa2, 0xdb, 0x83, 0x36, 0xfe, 0x61, 0x12, 0xda, 0x6d, 0xb4, 0x33,
+	0xef, 0xfc, 0x37, 0xaf, 0xb7, 0xde, 0x4e, 0x12, 0x17, 0xb5, 0x6c, 0xdb, 0xb9, 0xb7, 0x9b, 0xf4,
-	0x32, 0x87, 0x10, 0x8e, 0x52, 0x67, 0x18, 0xc7, 0x90, 0xd9, 0x66, 0xc5, 0x5b, 0x84, 0xbe, 0x20,
+	0x6e, 0xeb, 0x8d, 0x7e, 0xd8, 0x84, 0xee, 0x0f, 0xba, 0xb7, 0x32, 0x8f, 0x90, 0x58, 0x0a, 0x55,
-	0x56, 0x9a, 0x07, 0xb1, 0xe0, 0xfe, 0x12, 0x4a, 0x3f, 0xc9, 0x63, 0x2d, 0x02, 0xa6, 0xc0, 0xee,
+	0xca, 0x2c, 0x83, 0xd2, 0xb5, 0xb5, 0xde, 0x51, 0xe8, 0x0b, 0xe2, 0x14, 0x55, 0x94, 0xf1, 0x38,
-	0x57, 0x4e, 0x5a, 0x6b, 0x1f, 0xa0, 0x9c, 0xed, 0x15, 0xfa, 0x89, 0x5c, 0xb4, 0x2a, 0xbe, 0xad,
+	0x9c, 0x43, 0x13, 0xe6, 0x55, 0xa6, 0x78, 0xc4, 0x10, 0xdc, 0xbe, 0x26, 0xa9, 0xf1, 0x3e, 0x40,
-	0x96, 0xaa, 0x1a, 0xdb, 0xe0, 0xfa, 0xf9, 0xdd, 0xf3, 0x77, 0x3f, 0xee, 0x73, 0xde, 0xaf, 0x96,
+	0x33, 0xd9, 0x38, 0xf4, 0x13, 0x39, 0xed, 0x64, 0x7c, 0x5b, 0xcc, 0x51, 0xaf, 0xed, 0xf8, 0xe2,
-	0xea, 0x9d, 0xd4, 0x59, 0x39, 0x7f, 0x98, 0xb6, 0xd9, 0xf0, 0x0d, 0xa1, 0x5d, 0x13, 0xbd, 0x24,
+	0xf9, 0xed, 0xfb, 0xf7, 0x3f, 0x6e, 0xea, 0xbc, 0x5f, 0xcc, 0xf1, 0xad, 0x50, 0x65, 0x33, 0x7d,
-	0xfd, 0x25, 0x94, 0x4d, 0x3f, 0xbb, 0x23, 0xb5, 0xc8, 0x49, 0xc1, 0xe2, 0x1c, 0x9a, 0x5e, 0xea,
+	0x50, 0x74, 0xb5, 0xc1, 0x1b, 0x42, 0xf7, 0x21, 0x7a, 0x46, 0xfa, 0x73, 0x68, 0xda, 0x79, 0xd6,
-	0xcb, 0x2b, 0xf3, 0xa5, 0xf1, 0xf6, 0xf5, 0xef, 0x8d, 0x63, 0xac, 0x37, 0x8e, 0xf1, 0x77, 0xe3,
+	0x21, 0x75, 0xc8, 0x41, 0xcd, 0xb2, 0x0a, 0xda, 0x59, 0xcc, 0xe3, 0x95, 0xfd, 0xd2, 0xba, 0x7a,
-	0x18, 0x3f, 0xb7, 0x4e, 0x6f, 0xbd, 0x75, 0x7a, 0x7f, 0xb6, 0x4e, 0xef, 0xcb, 0x38, 0x12, 0x7a,
+	0xfd, 0x7b, 0xe9, 0x59, 0x37, 0x4b, 0xcf, 0xfa, 0xbb, 0xf4, 0xac, 0x9f, 0x2b, 0xaf, 0x77, 0xb3,
-	0x91, 0x07, 0x2e, 0xc7, 0xc4, 0x43, 0xa9, 0x50, 0x66, 0xde, 0x62, 0xc5, 0x4a, 0xef, 0xbb, 0xb7,
+	0xf2, 0x7a, 0x7f, 0x56, 0x5e, 0xef, 0xcb, 0x28, 0xe5, 0x6a, 0x56, 0x45, 0x7e, 0x2c, 0xf3, 0x40,
-	0x5b, 0x43, 0x5d, 0xa6, 0xa0, 0x82, 0xd3, 0x6a, 0x05, 0x6f, 0xfe, 0x05, 0x00, 0x00, 0xff, 0xff,
+	0x0a, 0x94, 0xa2, 0x0c, 0x66, 0x0b, 0xd6, 0x04, 0xdf, 0x83, 0xf5, 0xe1, 0xea, 0x53, 0x8f, 0x0e,
-	0x27, 0xff, 0x98, 0x0b, 0xe9, 0x02, 0x00, 0x00,
+	0xf5, 0x0d, 0x5e, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x5e, 0x30, 0x32, 0xf6, 0x01, 0x03, 0x00,
+	0x00,
 }
 
-func (m *DIDDocument) Marshal() (dAtA []byte, err error) {
+func (m *BaseDocument) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -230,12 +232,12 @@ func (m *DIDDocument) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *DIDDocument) MarshalTo(dAtA []byte) (int, error) {
+func (m *BaseDocument) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *DIDDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *BaseDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -244,7 +246,7 @@ func (m *DIDDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		for iNdEx := len(m.CapabilityInvocation) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.CapabilityInvocation[iNdEx])
 			copy(dAtA[i:], m.CapabilityInvocation[iNdEx])
-			i = encodeVarintAccount(dAtA, i, uint64(len(m.CapabilityInvocation[iNdEx])))
+			i = encodeVarintTypes(dAtA, i, uint64(len(m.CapabilityInvocation[iNdEx])))
 			i--
 			dAtA[i] = 0x42
 		}
@@ -253,7 +255,7 @@ func (m *DIDDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		for iNdEx := len(m.CapabilityDelegation) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.CapabilityDelegation[iNdEx])
 			copy(dAtA[i:], m.CapabilityDelegation[iNdEx])
-			i = encodeVarintAccount(dAtA, i, uint64(len(m.CapabilityDelegation[iNdEx])))
+			i = encodeVarintTypes(dAtA, i, uint64(len(m.CapabilityDelegation[iNdEx])))
 			i--
 			dAtA[i] = 0x3a
 		}
@@ -262,7 +264,7 @@ func (m *DIDDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		for iNdEx := len(m.AssertionMethod) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.AssertionMethod[iNdEx])
 			copy(dAtA[i:], m.AssertionMethod[iNdEx])
-			i = encodeVarintAccount(dAtA, i, uint64(len(m.AssertionMethod[iNdEx])))
+			i = encodeVarintTypes(dAtA, i, uint64(len(m.AssertionMethod[iNdEx])))
 			i--
 			dAtA[i] = 0x2a
 		}
@@ -271,7 +273,7 @@ func (m *DIDDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		for iNdEx := len(m.Authentication) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.Authentication[iNdEx])
 			copy(dAtA[i:], m.Authentication[iNdEx])
-			i = encodeVarintAccount(dAtA, i, uint64(len(m.Authentication[iNdEx])))
+			i = encodeVarintTypes(dAtA, i, uint64(len(m.Authentication[iNdEx])))
 			i--
 			dAtA[i] = 0x22
 		}
@@ -284,7 +286,7 @@ func (m *DIDDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 					return 0, err
 				}
 				i -= size
-				i = encodeVarintAccount(dAtA, i, uint64(size))
+				i = encodeVarintTypes(dAtA, i, uint64(size))
 			}
 			i--
 			dAtA[i] = 0x12
@@ -293,7 +295,7 @@ func (m *DIDDocument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Id) > 0 {
 		i -= len(m.Id)
 		copy(dAtA[i:], m.Id)
-		i = encodeVarintAccount(dAtA, i, uint64(len(m.Id)))
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Id)))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -326,15 +328,15 @@ func (m *VerificationMethod) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			baseI := i
 			i -= len(v)
 			copy(dAtA[i:], v)
-			i = encodeVarintAccount(dAtA, i, uint64(len(v)))
+			i = encodeVarintTypes(dAtA, i, uint64(len(v)))
 			i--
 			dAtA[i] = 0x12
 			i -= len(k)
 			copy(dAtA[i:], k)
-			i = encodeVarintAccount(dAtA, i, uint64(len(k)))
+			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
 			i--
 			dAtA[i] = 0xa
-			i = encodeVarintAccount(dAtA, i, uint64(baseI-i))
+			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
 			i--
 			dAtA[i] = 0x22
 		}
@@ -342,29 +344,29 @@ func (m *VerificationMethod) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.PublicKeyMultibase) > 0 {
 		i -= len(m.PublicKeyMultibase)
 		copy(dAtA[i:], m.PublicKeyMultibase)
-		i = encodeVarintAccount(dAtA, i, uint64(len(m.PublicKeyMultibase)))
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.PublicKeyMultibase)))
 		i--
 		dAtA[i] = 0x1a
 	}
 	if len(m.Controller) > 0 {
 		i -= len(m.Controller)
 		copy(dAtA[i:], m.Controller)
-		i = encodeVarintAccount(dAtA, i, uint64(len(m.Controller)))
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Controller)))
 		i--
 		dAtA[i] = 0x12
 	}
 	if len(m.Id) > 0 {
 		i -= len(m.Id)
 		copy(dAtA[i:], m.Id)
-		i = encodeVarintAccount(dAtA, i, uint64(len(m.Id)))
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Id)))
 		i--
 		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func encodeVarintAccount(dAtA []byte, offset int, v uint64) int {
+func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
-	offset -= sovAccount(v)
+	offset -= sovTypes(v)
 	base := offset
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -374,7 +376,7 @@ func encodeVarintAccount(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
-func (m *DIDDocument) Size() (n int) {
+func (m *BaseDocument) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -382,36 +384,36 @@ func (m *DIDDocument) Size() (n int) {
 	_ = l
 	l = len(m.Id)
 	if l > 0 {
-		n += 1 + l + sovAccount(uint64(l))
+		n += 1 + l + sovTypes(uint64(l))
 	}
 	if len(m.VerificationMethods) > 0 {
 		for _, e := range m.VerificationMethods {
 			l = e.Size()
-			n += 1 + l + sovAccount(uint64(l))
+			n += 1 + l + sovTypes(uint64(l))
 		}
 	}
 	if len(m.Authentication) > 0 {
 		for _, s := range m.Authentication {
 			l = len(s)
-			n += 1 + l + sovAccount(uint64(l))
+			n += 1 + l + sovTypes(uint64(l))
 		}
 	}
 	if len(m.AssertionMethod) > 0 {
 		for _, s := range m.AssertionMethod {
 			l = len(s)
-			n += 1 + l + sovAccount(uint64(l))
+			n += 1 + l + sovTypes(uint64(l))
 		}
 	}
 	if len(m.CapabilityDelegation) > 0 {
 		for _, s := range m.CapabilityDelegation {
 			l = len(s)
-			n += 1 + l + sovAccount(uint64(l))
+			n += 1 + l + sovTypes(uint64(l))
 		}
 	}
 	if len(m.CapabilityInvocation) > 0 {
 		for _, s := range m.CapabilityInvocation {
 			l = len(s)
-			n += 1 + l + sovAccount(uint64(l))
+			n += 1 + l + sovTypes(uint64(l))
 		}
 	}
 	return n
@@ -425,34 +427,34 @@ func (m *VerificationMethod) Size() (n int) {
 	_ = l
 	l = len(m.Id)
 	if l > 0 {
-		n += 1 + l + sovAccount(uint64(l))
+		n += 1 + l + sovTypes(uint64(l))
 	}
 	l = len(m.Controller)
 	if l > 0 {
-		n += 1 + l + sovAccount(uint64(l))
+		n += 1 + l + sovTypes(uint64(l))
 	}
 	l = len(m.PublicKeyMultibase)
 	if l > 0 {
-		n += 1 + l + sovAccount(uint64(l))
+		n += 1 + l + sovTypes(uint64(l))
 	}
 	if len(m.PublicKeyJwks) > 0 {
 		for k, v := range m.PublicKeyJwks {
 			_ = k
 			_ = v
-			mapEntrySize := 1 + len(k) + sovAccount(uint64(len(k))) + 1 + len(v) + sovAccount(uint64(len(v)))
+			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + len(v) + sovTypes(uint64(len(v)))
-			n += mapEntrySize + 1 + sovAccount(uint64(mapEntrySize))
+			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
 		}
 	}
 	return n
 }
 
-func sovAccount(x uint64) (n int) {
+func sovTypes(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
-func sozAccount(x uint64) (n int) {
+func sozTypes(x uint64) (n int) {
-	return sovAccount(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
-func (m *DIDDocument) Unmarshal(dAtA []byte) error {
+func (m *BaseDocument) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -460,7 +462,7 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
 			if shift >= 64 {
-				return ErrIntOverflowAccount
+				return ErrIntOverflowTypes
 			}
 			if iNdEx >= l {
 				return io.ErrUnexpectedEOF
@@ -475,10 +477,10 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DIDDocument: wiretype end group for non-group")
+			return fmt.Errorf("proto: BaseDocument: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DIDDocument: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: BaseDocument: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -488,7 +490,7 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -502,11 +504,11 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -520,7 +522,7 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -533,11 +535,11 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 				}
 			}
 			if msglen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + msglen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -554,7 +556,7 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -568,11 +570,11 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -586,7 +588,7 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -600,11 +602,11 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -618,7 +620,7 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -632,11 +634,11 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -650,7 +652,7 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -664,11 +666,11 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -677,12 +679,12 @@ func (m *DIDDocument) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
-			skippy, err := skipAccount(dAtA[iNdEx:])
+			skippy, err := skipTypes(dAtA[iNdEx:])
 			if err != nil {
 				return err
 			}
 			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
@@ -704,7 +706,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
 			if shift >= 64 {
-				return ErrIntOverflowAccount
+				return ErrIntOverflowTypes
 			}
 			if iNdEx >= l {
 				return io.ErrUnexpectedEOF
@@ -732,7 +734,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -746,11 +748,11 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -764,7 +766,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -778,11 +780,11 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -796,7 +798,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -810,11 +812,11 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 			}
 			intStringLen := int(stringLen)
 			if intStringLen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -828,7 +830,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return ErrIntOverflowAccount
+					return ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
@@ -841,11 +843,11 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 				}
 			}
 			if msglen < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			postIndex := iNdEx + msglen
 			if postIndex < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
@@ -860,7 +862,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 				var wire uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
-						return ErrIntOverflowAccount
+						return ErrIntOverflowTypes
 					}
 					if iNdEx >= l {
 						return io.ErrUnexpectedEOF
@@ -877,7 +879,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 					var stringLenmapkey uint64
 					for shift := uint(0); ; shift += 7 {
 						if shift >= 64 {
-							return ErrIntOverflowAccount
+							return ErrIntOverflowTypes
 						}
 						if iNdEx >= l {
 							return io.ErrUnexpectedEOF
@@ -891,11 +893,11 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 					}
 					intStringLenmapkey := int(stringLenmapkey)
 					if intStringLenmapkey < 0 {
-						return ErrInvalidLengthAccount
+						return ErrInvalidLengthTypes
 					}
 					postStringIndexmapkey := iNdEx + intStringLenmapkey
 					if postStringIndexmapkey < 0 {
-						return ErrInvalidLengthAccount
+						return ErrInvalidLengthTypes
 					}
 					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
@@ -906,7 +908,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 					var stringLenmapvalue uint64
 					for shift := uint(0); ; shift += 7 {
 						if shift >= 64 {
-							return ErrIntOverflowAccount
+							return ErrIntOverflowTypes
 						}
 						if iNdEx >= l {
 							return io.ErrUnexpectedEOF
@@ -920,11 +922,11 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 					}
 					intStringLenmapvalue := int(stringLenmapvalue)
 					if intStringLenmapvalue < 0 {
-						return ErrInvalidLengthAccount
+						return ErrInvalidLengthTypes
 					}
 					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
 					if postStringIndexmapvalue < 0 {
-						return ErrInvalidLengthAccount
+						return ErrInvalidLengthTypes
 					}
 					if postStringIndexmapvalue > l {
 						return io.ErrUnexpectedEOF
@@ -933,12 +935,12 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 					iNdEx = postStringIndexmapvalue
 				} else {
 					iNdEx = entryPreIndex
-					skippy, err := skipAccount(dAtA[iNdEx:])
+					skippy, err := skipTypes(dAtA[iNdEx:])
 					if err != nil {
 						return err
 					}
 					if (skippy < 0) || (iNdEx+skippy) < 0 {
-						return ErrInvalidLengthAccount
+						return ErrInvalidLengthTypes
 					}
 					if (iNdEx + skippy) > postIndex {
 						return io.ErrUnexpectedEOF
@@ -950,12 +952,12 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
-			skippy, err := skipAccount(dAtA[iNdEx:])
+			skippy, err := skipTypes(dAtA[iNdEx:])
 			if err != nil {
 				return err
 			}
 			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthAccount
+				return ErrInvalidLengthTypes
 			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
@@ -969,7 +971,7 @@ func (m *VerificationMethod) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func skipAccount(dAtA []byte) (n int, err error) {
+func skipTypes(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
 	depth := 0
@@ -977,7 +979,7 @@ func skipAccount(dAtA []byte) (n int, err error) {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
 			if shift >= 64 {
-				return 0, ErrIntOverflowAccount
+				return 0, ErrIntOverflowTypes
 			}
 			if iNdEx >= l {
 				return 0, io.ErrUnexpectedEOF
@@ -994,7 +996,7 @@ func skipAccount(dAtA []byte) (n int, err error) {
 		case 0:
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return 0, ErrIntOverflowAccount
+					return 0, ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return 0, io.ErrUnexpectedEOF
@@ -1010,7 +1012,7 @@ func skipAccount(dAtA []byte) (n int, err error) {
 			var length int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
-					return 0, ErrIntOverflowAccount
+					return 0, ErrIntOverflowTypes
 				}
 				if iNdEx >= l {
 					return 0, io.ErrUnexpectedEOF
@@ -1023,14 +1025,14 @@ func skipAccount(dAtA []byte) (n int, err error) {
 				}
 			}
 			if length < 0 {
-				return 0, ErrInvalidLengthAccount
+				return 0, ErrInvalidLengthTypes
 			}
 			iNdEx += length
 		case 3:
 			depth++
 		case 4:
 			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupAccount
+				return 0, ErrUnexpectedEndOfGroupTypes
 			}
 			depth--
 		case 5:
@@ -1039,7 +1041,7 @@ func skipAccount(dAtA []byte) (n int, err error) {
 			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 		}
 		if iNdEx < 0 {
-			return 0, ErrInvalidLengthAccount
+			return 0, ErrInvalidLengthTypes
 		}
 		if depth == 0 {
 			return iNdEx, nil
@@ -1049,7 +1051,7 @@ func skipAccount(dAtA []byte) (n int, err error) {
 }
 
 var (
-	ErrInvalidLengthAccount        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowAccount          = fmt.Errorf("proto: integer overflow")
+	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupAccount = fmt.Errorf("proto: unexpected end of group")
+	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
 )