refactor: rename Assertion to Account and update related code

api/dwn/v1/state.cosmos_orm.go

@@ -9,145 +9,278 @@ import (
 	ormerrors "cosmossdk.io/orm/types/ormerrors"
 )
 
-type ExampleDataTable interface {
-	Insert(ctx context.Context, exampleData *ExampleData) error
-	Update(ctx context.Context, exampleData *ExampleData) error
-	Save(ctx context.Context, exampleData *ExampleData) error
-	Delete(ctx context.Context, exampleData *ExampleData) error
+type CredentialTable interface {
+	Insert(ctx context.Context, credential *Credential) error
+	Update(ctx context.Context, credential *Credential) error
+	Save(ctx context.Context, credential *Credential) error
+	Delete(ctx context.Context, credential *Credential) error
 	Has(ctx context.Context, account []byte) (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, account []byte) (*ExampleData, error)
-	List(ctx context.Context, prefixKey ExampleDataIndexKey, opts ...ormlist.Option) (ExampleDataIterator, error)
-	ListRange(ctx context.Context, from, to ExampleDataIndexKey, opts ...ormlist.Option) (ExampleDataIterator, error)
-	DeleteBy(ctx context.Context, prefixKey ExampleDataIndexKey) error
-	DeleteRange(ctx context.Context, from, to ExampleDataIndexKey) error
+	Get(ctx context.Context, account []byte) (*Credential, error)
+	List(ctx context.Context, prefixKey CredentialIndexKey, opts ...ormlist.Option) (CredentialIterator, error)
+	ListRange(ctx context.Context, from, to CredentialIndexKey, opts ...ormlist.Option) (CredentialIterator, error)
+	DeleteBy(ctx context.Context, prefixKey CredentialIndexKey) error
+	DeleteRange(ctx context.Context, from, to CredentialIndexKey) error
 
 	doNotImplement()
 }
 
-type ExampleDataIterator struct {
+type CredentialIterator struct {
 	ormtable.Iterator
 }
 
-func (i ExampleDataIterator) Value() (*ExampleData, error) {
-	var exampleData ExampleData
-	err := i.UnmarshalMessage(&exampleData)
-	return &exampleData, err
+func (i CredentialIterator) Value() (*Credential, error) {
+	var credential Credential
+	err := i.UnmarshalMessage(&credential)
+	return &credential, err
 }
 
-type ExampleDataIndexKey interface {
+type CredentialIndexKey interface {
 	id() uint32
 	values() []interface{}
-	exampleDataIndexKey()
+	credentialIndexKey()
 }
 
 // primary key starting index..
-type ExampleDataPrimaryKey = ExampleDataAccountIndexKey
+type CredentialPrimaryKey = CredentialAccountIndexKey
 
-type ExampleDataAccountIndexKey struct {
+type CredentialAccountIndexKey struct {
 	vs []interface{}
 }
 
-func (x ExampleDataAccountIndexKey) id() uint32            { return 0 }
-func (x ExampleDataAccountIndexKey) values() []interface{} { return x.vs }
-func (x ExampleDataAccountIndexKey) exampleDataIndexKey()  {}
+func (x CredentialAccountIndexKey) id() uint32            { return 0 }
+func (x CredentialAccountIndexKey) values() []interface{} { return x.vs }
+func (x CredentialAccountIndexKey) credentialIndexKey()   {}
 
-func (this ExampleDataAccountIndexKey) WithAccount(account []byte) ExampleDataAccountIndexKey {
+func (this CredentialAccountIndexKey) WithAccount(account []byte) CredentialAccountIndexKey {
 	this.vs = []interface{}{account}
 	return this
 }
 
-type ExampleDataAmountIndexKey struct {
+type CredentialAmountIndexKey struct {
 	vs []interface{}
 }
 
-func (x ExampleDataAmountIndexKey) id() uint32            { return 1 }
-func (x ExampleDataAmountIndexKey) values() []interface{} { return x.vs }
-func (x ExampleDataAmountIndexKey) exampleDataIndexKey()  {}
+func (x CredentialAmountIndexKey) id() uint32            { return 1 }
+func (x CredentialAmountIndexKey) values() []interface{} { return x.vs }
+func (x CredentialAmountIndexKey) credentialIndexKey()   {}
 
-func (this ExampleDataAmountIndexKey) WithAmount(amount uint64) ExampleDataAmountIndexKey {
+func (this CredentialAmountIndexKey) WithAmount(amount uint64) CredentialAmountIndexKey {
 	this.vs = []interface{}{amount}
 	return this
 }
 
-type exampleDataTable struct {
+type credentialTable struct {
 	table ormtable.Table
 }
 
-func (this exampleDataTable) Insert(ctx context.Context, exampleData *ExampleData) error {
-	return this.table.Insert(ctx, exampleData)
+func (this credentialTable) Insert(ctx context.Context, credential *Credential) error {
+	return this.table.Insert(ctx, credential)
 }
 
-func (this exampleDataTable) Update(ctx context.Context, exampleData *ExampleData) error {
-	return this.table.Update(ctx, exampleData)
+func (this credentialTable) Update(ctx context.Context, credential *Credential) error {
+	return this.table.Update(ctx, credential)
 }
 
-func (this exampleDataTable) Save(ctx context.Context, exampleData *ExampleData) error {
-	return this.table.Save(ctx, exampleData)
+func (this credentialTable) Save(ctx context.Context, credential *Credential) error {
+	return this.table.Save(ctx, credential)
 }
 
-func (this exampleDataTable) Delete(ctx context.Context, exampleData *ExampleData) error {
-	return this.table.Delete(ctx, exampleData)
+func (this credentialTable) Delete(ctx context.Context, credential *Credential) error {
+	return this.table.Delete(ctx, credential)
 }
 
-func (this exampleDataTable) Has(ctx context.Context, account []byte) (found bool, err error) {
+func (this credentialTable) Has(ctx context.Context, account []byte) (found bool, err error) {
 	return this.table.PrimaryKey().Has(ctx, account)
 }
 
-func (this exampleDataTable) Get(ctx context.Context, account []byte) (*ExampleData, error) {
-	var exampleData ExampleData
-	found, err := this.table.PrimaryKey().Get(ctx, &exampleData, account)
+func (this credentialTable) Get(ctx context.Context, account []byte) (*Credential, error) {
+	var credential Credential
+	found, err := this.table.PrimaryKey().Get(ctx, &credential, account)
 	if err != nil {
 		return nil, err
 	}
 	if !found {
 		return nil, ormerrors.NotFound
 	}
-	return &exampleData, nil
+	return &credential, nil
 }
 
-func (this exampleDataTable) List(ctx context.Context, prefixKey ExampleDataIndexKey, opts ...ormlist.Option) (ExampleDataIterator, error) {
+func (this credentialTable) List(ctx context.Context, prefixKey CredentialIndexKey, opts ...ormlist.Option) (CredentialIterator, error) {
 	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
-	return ExampleDataIterator{it}, err
+	return CredentialIterator{it}, err
 }
 
-func (this exampleDataTable) ListRange(ctx context.Context, from, to ExampleDataIndexKey, opts ...ormlist.Option) (ExampleDataIterator, error) {
+func (this credentialTable) ListRange(ctx context.Context, from, to CredentialIndexKey, opts ...ormlist.Option) (CredentialIterator, error) {
 	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
-	return ExampleDataIterator{it}, err
+	return CredentialIterator{it}, err
 }
 
-func (this exampleDataTable) DeleteBy(ctx context.Context, prefixKey ExampleDataIndexKey) error {
+func (this credentialTable) DeleteBy(ctx context.Context, prefixKey CredentialIndexKey) error {
 	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
 }
 
-func (this exampleDataTable) DeleteRange(ctx context.Context, from, to ExampleDataIndexKey) error {
+func (this credentialTable) DeleteRange(ctx context.Context, from, to CredentialIndexKey) error {
 	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
 }
 
-func (this exampleDataTable) doNotImplement() {}
+func (this credentialTable) doNotImplement() {}
 
-var _ ExampleDataTable = exampleDataTable{}
+var _ CredentialTable = credentialTable{}
 
-func NewExampleDataTable(db ormtable.Schema) (ExampleDataTable, error) {
-	table := db.GetTable(&ExampleData{})
+func NewCredentialTable(db ormtable.Schema) (CredentialTable, error) {
+	table := db.GetTable(&Credential{})
 	if table == nil {
-		return nil, ormerrors.TableNotFound.Wrap(string((&ExampleData{}).ProtoReflect().Descriptor().FullName()))
+		return nil, ormerrors.TableNotFound.Wrap(string((&Credential{}).ProtoReflect().Descriptor().FullName()))
 	}
-	return exampleDataTable{table}, nil
+	return credentialTable{table}, nil
+}
+
+type ProfileTable interface {
+	Insert(ctx context.Context, profile *Profile) error
+	Update(ctx context.Context, profile *Profile) error
+	Save(ctx context.Context, profile *Profile) error
+	Delete(ctx context.Context, profile *Profile) error
+	Has(ctx context.Context, account []byte) (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, account []byte) (*Profile, error)
+	List(ctx context.Context, prefixKey ProfileIndexKey, opts ...ormlist.Option) (ProfileIterator, error)
+	ListRange(ctx context.Context, from, to ProfileIndexKey, opts ...ormlist.Option) (ProfileIterator, error)
+	DeleteBy(ctx context.Context, prefixKey ProfileIndexKey) error
+	DeleteRange(ctx context.Context, from, to ProfileIndexKey) error
+
+	doNotImplement()
+}
+
+type ProfileIterator struct {
+	ormtable.Iterator
+}
+
+func (i ProfileIterator) Value() (*Profile, error) {
+	var profile Profile
+	err := i.UnmarshalMessage(&profile)
+	return &profile, err
+}
+
+type ProfileIndexKey interface {
+	id() uint32
+	values() []interface{}
+	profileIndexKey()
+}
+
+// primary key starting index..
+type ProfilePrimaryKey = ProfileAccountIndexKey
+
+type ProfileAccountIndexKey struct {
+	vs []interface{}
+}
+
+func (x ProfileAccountIndexKey) id() uint32            { return 0 }
+func (x ProfileAccountIndexKey) values() []interface{} { return x.vs }
+func (x ProfileAccountIndexKey) profileIndexKey()      {}
+
+func (this ProfileAccountIndexKey) WithAccount(account []byte) ProfileAccountIndexKey {
+	this.vs = []interface{}{account}
+	return this
+}
+
+type ProfileAmountIndexKey struct {
+	vs []interface{}
+}
+
+func (x ProfileAmountIndexKey) id() uint32            { return 1 }
+func (x ProfileAmountIndexKey) values() []interface{} { return x.vs }
+func (x ProfileAmountIndexKey) profileIndexKey()      {}
+
+func (this ProfileAmountIndexKey) WithAmount(amount uint64) ProfileAmountIndexKey {
+	this.vs = []interface{}{amount}
+	return this
+}
+
+type profileTable struct {
+	table ormtable.Table
+}
+
+func (this profileTable) Insert(ctx context.Context, profile *Profile) error {
+	return this.table.Insert(ctx, profile)
+}
+
+func (this profileTable) Update(ctx context.Context, profile *Profile) error {
+	return this.table.Update(ctx, profile)
+}
+
+func (this profileTable) Save(ctx context.Context, profile *Profile) error {
+	return this.table.Save(ctx, profile)
+}
+
+func (this profileTable) Delete(ctx context.Context, profile *Profile) error {
+	return this.table.Delete(ctx, profile)
+}
+
+func (this profileTable) Has(ctx context.Context, account []byte) (found bool, err error) {
+	return this.table.PrimaryKey().Has(ctx, account)
+}
+
+func (this profileTable) Get(ctx context.Context, account []byte) (*Profile, error) {
+	var profile Profile
+	found, err := this.table.PrimaryKey().Get(ctx, &profile, account)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &profile, nil
+}
+
+func (this profileTable) List(ctx context.Context, prefixKey ProfileIndexKey, opts ...ormlist.Option) (ProfileIterator, error) {
+	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
+	return ProfileIterator{it}, err
+}
+
+func (this profileTable) ListRange(ctx context.Context, from, to ProfileIndexKey, opts ...ormlist.Option) (ProfileIterator, error) {
+	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
+	return ProfileIterator{it}, err
+}
+
+func (this profileTable) DeleteBy(ctx context.Context, prefixKey ProfileIndexKey) error {
+	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
+}
+
+func (this profileTable) DeleteRange(ctx context.Context, from, to ProfileIndexKey) error {
+	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
+}
+
+func (this profileTable) doNotImplement() {}
+
+var _ ProfileTable = profileTable{}
+
+func NewProfileTable(db ormtable.Schema) (ProfileTable, error) {
+	table := db.GetTable(&Profile{})
+	if table == nil {
+		return nil, ormerrors.TableNotFound.Wrap(string((&Profile{}).ProtoReflect().Descriptor().FullName()))
+	}
+	return profileTable{table}, nil
 }
 
 type StateStore interface {
-	ExampleDataTable() ExampleDataTable
+	CredentialTable() CredentialTable
+	ProfileTable() ProfileTable
 
 	doNotImplement()
 }
 
 type stateStore struct {
-	exampleData ExampleDataTable
+	credential CredentialTable
+	profile    ProfileTable
 }
 
-func (x stateStore) ExampleDataTable() ExampleDataTable {
-	return x.exampleData
+func (x stateStore) CredentialTable() CredentialTable {
+	return x.credential
+}
+
+func (x stateStore) ProfileTable() ProfileTable {
+	return x.profile
 }
 
 func (stateStore) doNotImplement() {}
@@ -155,12 +288,18 @@ func (stateStore) doNotImplement() {}
 var _ StateStore = stateStore{}
 
 func NewStateStore(db ormtable.Schema) (StateStore, error) {
-	exampleDataTable, err := NewExampleDataTable(db)
+	credentialTable, err := NewCredentialTable(db)
+	if err != nil {
+		return nil, err
+	}
+
+	profileTable, err := NewProfileTable(db)
 	if err != nil {
 		return nil, err
 	}
 
 	return stateStore{
-		exampleDataTable,
+		credentialTable,
+		profileTable,
 	}, nil
 }

api/dwn/v1/state.pulsar.go

@@ -14,27 +14,27 @@ import (
 )
 
 var (
-	md_ExampleData         protoreflect.MessageDescriptor
-	fd_ExampleData_account protoreflect.FieldDescriptor
-	fd_ExampleData_amount  protoreflect.FieldDescriptor
+	md_Credential         protoreflect.MessageDescriptor
+	fd_Credential_account protoreflect.FieldDescriptor
+	fd_Credential_amount  protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_dwn_v1_state_proto_init()
-	md_ExampleData = File_dwn_v1_state_proto.Messages().ByName("ExampleData")
-	fd_ExampleData_account = md_ExampleData.Fields().ByName("account")
-	fd_ExampleData_amount = md_ExampleData.Fields().ByName("amount")
+	md_Credential = File_dwn_v1_state_proto.Messages().ByName("Credential")
+	fd_Credential_account = md_Credential.Fields().ByName("account")
+	fd_Credential_amount = md_Credential.Fields().ByName("amount")
 }
 
-var _ protoreflect.Message = (*fastReflection_ExampleData)(nil)
+var _ protoreflect.Message = (*fastReflection_Credential)(nil)
 
-type fastReflection_ExampleData ExampleData
+type fastReflection_Credential Credential
 
-func (x *ExampleData) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_ExampleData)(x)
+func (x *Credential) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Credential)(x)
 }
 
-func (x *ExampleData) slowProtoReflect() protoreflect.Message {
+func (x *Credential) slowProtoReflect() protoreflect.Message {
 	mi := &file_dwn_v1_state_proto_msgTypes[0]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -46,43 +46,43 @@ func (x *ExampleData) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_ExampleData_messageType fastReflection_ExampleData_messageType
-var _ protoreflect.MessageType = fastReflection_ExampleData_messageType{}
+var _fastReflection_Credential_messageType fastReflection_Credential_messageType
+var _ protoreflect.MessageType = fastReflection_Credential_messageType{}
 
-type fastReflection_ExampleData_messageType struct{}
+type fastReflection_Credential_messageType struct{}
 
-func (x fastReflection_ExampleData_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_ExampleData)(nil)
+func (x fastReflection_Credential_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Credential)(nil)
 }
-func (x fastReflection_ExampleData_messageType) New() protoreflect.Message {
-	return new(fastReflection_ExampleData)
+func (x fastReflection_Credential_messageType) New() protoreflect.Message {
+	return new(fastReflection_Credential)
 }
-func (x fastReflection_ExampleData_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_ExampleData
+func (x fastReflection_Credential_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Credential
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_ExampleData) Descriptor() protoreflect.MessageDescriptor {
-	return md_ExampleData
+func (x *fastReflection_Credential) Descriptor() protoreflect.MessageDescriptor {
+	return md_Credential
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_ExampleData) Type() protoreflect.MessageType {
-	return _fastReflection_ExampleData_messageType
+func (x *fastReflection_Credential) Type() protoreflect.MessageType {
+	return _fastReflection_Credential_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_ExampleData) New() protoreflect.Message {
-	return new(fastReflection_ExampleData)
+func (x *fastReflection_Credential) New() protoreflect.Message {
+	return new(fastReflection_Credential)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_ExampleData) Interface() protoreflect.ProtoMessage {
-	return (*ExampleData)(x)
+func (x *fastReflection_Credential) Interface() protoreflect.ProtoMessage {
+	return (*Credential)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -90,16 +90,16 @@ func (x *fastReflection_ExampleData) Interface() protoreflect.ProtoMessage {
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_ExampleData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_Credential) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if len(x.Account) != 0 {
 		value := protoreflect.ValueOfBytes(x.Account)
-		if !f(fd_ExampleData_account, value) {
+		if !f(fd_Credential_account, value) {
 			return
 		}
 	}
 	if x.Amount != uint64(0) {
 		value := protoreflect.ValueOfUint64(x.Amount)
-		if !f(fd_ExampleData_amount, value) {
+		if !f(fd_Credential_amount, value) {
 			return
 		}
 	}
@@ -116,17 +116,17 @@ func (x *fastReflection_ExampleData) Range(f func(protoreflect.FieldDescriptor,
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_ExampleData) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_Credential) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "dwn.v1.ExampleData.account":
+	case "dwn.v1.Credential.account":
 		return len(x.Account) != 0
-	case "dwn.v1.ExampleData.amount":
+	case "dwn.v1.Credential.amount":
 		return x.Amount != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.ExampleData"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Credential"))
 		}
-		panic(fmt.Errorf("message dwn.v1.ExampleData does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message dwn.v1.Credential does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -136,17 +136,17 @@ func (x *fastReflection_ExampleData) Has(fd protoreflect.FieldDescriptor) bool {
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ExampleData) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_Credential) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "dwn.v1.ExampleData.account":
+	case "dwn.v1.Credential.account":
 		x.Account = nil
-	case "dwn.v1.ExampleData.amount":
+	case "dwn.v1.Credential.amount":
 		x.Amount = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.ExampleData"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Credential"))
 		}
-		panic(fmt.Errorf("message dwn.v1.ExampleData does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message dwn.v1.Credential does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -156,19 +156,19 @@ func (x *fastReflection_ExampleData) Clear(fd protoreflect.FieldDescriptor) {
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_ExampleData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_Credential) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "dwn.v1.ExampleData.account":
+	case "dwn.v1.Credential.account":
 		value := x.Account
 		return protoreflect.ValueOfBytes(value)
-	case "dwn.v1.ExampleData.amount":
+	case "dwn.v1.Credential.amount":
 		value := x.Amount
 		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.ExampleData"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Credential"))
 		}
-		panic(fmt.Errorf("message dwn.v1.ExampleData does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message dwn.v1.Credential does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -182,17 +182,17 @@ func (x *fastReflection_ExampleData) Get(descriptor protoreflect.FieldDescriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ExampleData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_Credential) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "dwn.v1.ExampleData.account":
+	case "dwn.v1.Credential.account":
 		x.Account = value.Bytes()
-	case "dwn.v1.ExampleData.amount":
+	case "dwn.v1.Credential.amount":
 		x.Amount = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.ExampleData"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Credential"))
 		}
-		panic(fmt.Errorf("message dwn.v1.ExampleData does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message dwn.v1.Credential does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -206,44 +206,44 @@ func (x *fastReflection_ExampleData) Set(fd protoreflect.FieldDescriptor, value
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ExampleData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_Credential) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "dwn.v1.ExampleData.account":
-		panic(fmt.Errorf("field account of message dwn.v1.ExampleData is not mutable"))
-	case "dwn.v1.ExampleData.amount":
-		panic(fmt.Errorf("field amount of message dwn.v1.ExampleData is not mutable"))
+	case "dwn.v1.Credential.account":
+		panic(fmt.Errorf("field account of message dwn.v1.Credential is not mutable"))
+	case "dwn.v1.Credential.amount":
+		panic(fmt.Errorf("field amount of message dwn.v1.Credential is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.ExampleData"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Credential"))
 		}
-		panic(fmt.Errorf("message dwn.v1.ExampleData does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message dwn.v1.Credential does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_ExampleData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_Credential) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "dwn.v1.ExampleData.account":
+	case "dwn.v1.Credential.account":
 		return protoreflect.ValueOfBytes(nil)
-	case "dwn.v1.ExampleData.amount":
+	case "dwn.v1.Credential.amount":
 		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.ExampleData"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Credential"))
 		}
-		panic(fmt.Errorf("message dwn.v1.ExampleData does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message dwn.v1.Credential does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_ExampleData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_Credential) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in dwn.v1.ExampleData", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in dwn.v1.Credential", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -251,7 +251,7 @@ func (x *fastReflection_ExampleData) WhichOneof(d protoreflect.OneofDescriptor)
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_ExampleData) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_Credential) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -262,7 +262,7 @@ func (x *fastReflection_ExampleData) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ExampleData) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_Credential) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -274,7 +274,7 @@ func (x *fastReflection_ExampleData) SetUnknown(fields protoreflect.RawFields) {
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_ExampleData) IsValid() bool {
+func (x *fastReflection_Credential) IsValid() bool {
 	return x != nil
 }
 
@@ -284,9 +284,9 @@ func (x *fastReflection_ExampleData) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_ExampleData) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_Credential) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*ExampleData)
+		x := input.Message.Interface().(*Credential)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -315,7 +315,7 @@ func (x *fastReflection_ExampleData) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*ExampleData)
+		x := input.Message.Interface().(*Credential)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -357,7 +357,7 @@ func (x *fastReflection_ExampleData) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*ExampleData)
+		x := input.Message.Interface().(*Credential)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -389,10 +389,480 @@ func (x *fastReflection_ExampleData) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ExampleData: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Credential: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ExampleData: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Credential: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
+				}
+				var byteLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					byteLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if byteLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + byteLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Account = append(x.Account[:0], dAtA[iNdEx:postIndex]...)
+				if x.Account == nil {
+					x.Account = []byte{}
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+				}
+				x.Amount = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Amount |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_Profile         protoreflect.MessageDescriptor
+	fd_Profile_account protoreflect.FieldDescriptor
+	fd_Profile_amount  protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_dwn_v1_state_proto_init()
+	md_Profile = File_dwn_v1_state_proto.Messages().ByName("Profile")
+	fd_Profile_account = md_Profile.Fields().ByName("account")
+	fd_Profile_amount = md_Profile.Fields().ByName("amount")
+}
+
+var _ protoreflect.Message = (*fastReflection_Profile)(nil)
+
+type fastReflection_Profile Profile
+
+func (x *Profile) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Profile)(x)
+}
+
+func (x *Profile) slowProtoReflect() protoreflect.Message {
+	mi := &file_dwn_v1_state_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_Profile_messageType fastReflection_Profile_messageType
+var _ protoreflect.MessageType = fastReflection_Profile_messageType{}
+
+type fastReflection_Profile_messageType struct{}
+
+func (x fastReflection_Profile_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Profile)(nil)
+}
+func (x fastReflection_Profile_messageType) New() protoreflect.Message {
+	return new(fastReflection_Profile)
+}
+func (x fastReflection_Profile_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Profile
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_Profile) Descriptor() protoreflect.MessageDescriptor {
+	return md_Profile
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_Profile) Type() protoreflect.MessageType {
+	return _fastReflection_Profile_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_Profile) New() protoreflect.Message {
+	return new(fastReflection_Profile)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_Profile) Interface() protoreflect.ProtoMessage {
+	return (*Profile)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_Profile) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Account) != 0 {
+		value := protoreflect.ValueOfBytes(x.Account)
+		if !f(fd_Profile_account, value) {
+			return
+		}
+	}
+	if x.Amount != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Amount)
+		if !f(fd_Profile_amount, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_Profile) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "dwn.v1.Profile.account":
+		return len(x.Account) != 0
+	case "dwn.v1.Profile.amount":
+		return x.Amount != uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Profile"))
+		}
+		panic(fmt.Errorf("message dwn.v1.Profile does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Profile) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "dwn.v1.Profile.account":
+		x.Account = nil
+	case "dwn.v1.Profile.amount":
+		x.Amount = uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Profile"))
+		}
+		panic(fmt.Errorf("message dwn.v1.Profile does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_Profile) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "dwn.v1.Profile.account":
+		value := x.Account
+		return protoreflect.ValueOfBytes(value)
+	case "dwn.v1.Profile.amount":
+		value := x.Amount
+		return protoreflect.ValueOfUint64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Profile"))
+		}
+		panic(fmt.Errorf("message dwn.v1.Profile does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Profile) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "dwn.v1.Profile.account":
+		x.Account = value.Bytes()
+	case "dwn.v1.Profile.amount":
+		x.Amount = value.Uint()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Profile"))
+		}
+		panic(fmt.Errorf("message dwn.v1.Profile does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Profile) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "dwn.v1.Profile.account":
+		panic(fmt.Errorf("field account of message dwn.v1.Profile is not mutable"))
+	case "dwn.v1.Profile.amount":
+		panic(fmt.Errorf("field amount of message dwn.v1.Profile is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Profile"))
+		}
+		panic(fmt.Errorf("message dwn.v1.Profile does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_Profile) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "dwn.v1.Profile.account":
+		return protoreflect.ValueOfBytes(nil)
+	case "dwn.v1.Profile.amount":
+		return protoreflect.ValueOfUint64(uint64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: dwn.v1.Profile"))
+		}
+		panic(fmt.Errorf("message dwn.v1.Profile does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_Profile) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in dwn.v1.Profile", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_Profile) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_Profile) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_Profile) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_Profile) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*Profile)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Account)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Amount != 0 {
+			n += 1 + runtime.Sov(uint64(x.Amount))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*Profile)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Amount != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Amount))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.Account) > 0 {
+			i -= len(x.Account)
+			copy(dAtA[i:], x.Account)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Account)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*Profile)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				wire |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			fieldNum := int32(wire >> 3)
+			wireType := int(wire & 0x7)
+			if wireType == 4 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Profile: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Profile: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -496,7 +966,7 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
-type ExampleData struct {
+type Credential struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
@@ -505,8 +975,8 @@ type ExampleData struct {
 	Amount  uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
 }
 
-func (x *ExampleData) Reset() {
-	*x = ExampleData{}
+func (x *Credential) Reset() {
+	*x = Credential{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_dwn_v1_state_proto_msgTypes[0]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -514,25 +984,68 @@ func (x *ExampleData) Reset() {
 	}
 }
 
-func (x *ExampleData) String() string {
+func (x *Credential) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ExampleData) ProtoMessage() {}
+func (*Credential) ProtoMessage() {}
 
-// Deprecated: Use ExampleData.ProtoReflect.Descriptor instead.
-func (*ExampleData) Descriptor() ([]byte, []int) {
+// Deprecated: Use Credential.ProtoReflect.Descriptor instead.
+func (*Credential) Descriptor() ([]byte, []int) {
 	return file_dwn_v1_state_proto_rawDescGZIP(), []int{0}
 }
 
-func (x *ExampleData) GetAccount() []byte {
+func (x *Credential) GetAccount() []byte {
 	if x != nil {
 		return x.Account
 	}
 	return nil
 }
 
-func (x *ExampleData) GetAmount() uint64 {
+func (x *Credential) GetAmount() uint64 {
+	if x != nil {
+		return x.Amount
+	}
+	return 0
+}
+
+type Profile struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Account []byte `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
+	Amount  uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (x *Profile) Reset() {
+	*x = Profile{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_dwn_v1_state_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Profile) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Profile) ProtoMessage() {}
+
+// Deprecated: Use Profile.ProtoReflect.Descriptor instead.
+func (*Profile) Descriptor() ([]byte, []int) {
+	return file_dwn_v1_state_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Profile) GetAccount() []byte {
+	if x != nil {
+		return x.Account
+	}
+	return nil
+}
+
+func (x *Profile) GetAmount() uint64 {
 	if x != nil {
 		return x.Amount
 	}
@@ -545,21 +1058,27 @@ var file_dwn_v1_state_proto_rawDesc = []byte{
 	0x0a, 0x12, 0x64, 0x77, 0x6e, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2e, 0x70,
 	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x64, 0x77, 0x6e, 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, 0x22, 0x60, 0x0a, 0x0b, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
-	0x44, 0x61, 0x74, 0x61, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16,
-	0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06,
-	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x1f, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x19, 0x0a, 0x09,
-	0x0a, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x0a, 0x0a, 0x06, 0x61, 0x6d, 0x6f,
-	0x75, 0x6e, 0x74, 0x10, 0x01, 0x18, 0x01, 0x42, 0x7a, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x64,
-	0x77, 0x6e, 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, 0x73, 0x6f, 0x6e, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f,
-	0x64, 0x77, 0x6e, 0x2f, 0x76, 0x31, 0x3b, 0x64, 0x77, 0x6e, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x44,
-	0x58, 0x58, 0xaa, 0x02, 0x06, 0x44, 0x77, 0x6e, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, 0x44, 0x77,
-	0x6e, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x12, 0x44, 0x77, 0x6e, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50,
-	0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x44, 0x77, 0x6e, 0x3a,
-	0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x5f, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74,
+	0x69, 0x61, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a,
+	0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61,
+	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x1f, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x19, 0x0a, 0x09, 0x0a,
+	0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x0a, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x10, 0x01, 0x18, 0x01, 0x22, 0x5c, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c,
+	0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x61,
+	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f,
+	0x75, 0x6e, 0x74, 0x3a, 0x1f, 0xf2, 0x9e, 0xd3, 0x8e, 0x03, 0x19, 0x0a, 0x09, 0x0a, 0x07, 0x61,
+	0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x0a, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
+	0x10, 0x01, 0x18, 0x02, 0x42, 0x7a, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x64, 0x77, 0x6e, 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, 0x73, 0x6f, 0x6e, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x64, 0x77, 0x6e,
+	0x2f, 0x76, 0x31, 0x3b, 0x64, 0x77, 0x6e, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x44, 0x58, 0x58, 0xaa,
+	0x02, 0x06, 0x44, 0x77, 0x6e, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x06, 0x44, 0x77, 0x6e, 0x5c, 0x56,
+	0x31, 0xe2, 0x02, 0x12, 0x44, 0x77, 0x6e, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65,
+	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x07, 0x44, 0x77, 0x6e, 0x3a, 0x3a, 0x56, 0x31,
+	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -574,9 +1093,10 @@ func file_dwn_v1_state_proto_rawDescGZIP() []byte {
 	return file_dwn_v1_state_proto_rawDescData
 }
 
-var file_dwn_v1_state_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_dwn_v1_state_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
 var file_dwn_v1_state_proto_goTypes = []interface{}{
-	(*ExampleData)(nil), // 0: dwn.v1.ExampleData
+	(*Credential)(nil), // 0: dwn.v1.Credential
+	(*Profile)(nil),    // 1: dwn.v1.Profile
 }
 var file_dwn_v1_state_proto_depIdxs = []int32{
 	0, // [0:0] is the sub-list for method output_type
@@ -593,7 +1113,19 @@ func file_dwn_v1_state_proto_init() {
 	}
 	if !protoimpl.UnsafeEnabled {
 		file_dwn_v1_state_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ExampleData); i {
+			switch v := v.(*Credential); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_dwn_v1_state_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Profile); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -611,7 +1143,7 @@ func file_dwn_v1_state_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_dwn_v1_state_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   1,
+			NumMessages:   2,
 			NumExtensions: 0,
 			NumServices:   0,
 		},