Feature/update dockerfile (#6)

* chore: remove unused new.Dockerfile

* feat: add DID model definitions

* fix: Fix EncodePublicKey method in KeyInfo struct

* feat: Update `EncodePublicKey` to be the inverse of `DecodePublicKey`

* refactor: update AssetInfo protobuf definition

* fix: update default assets with correct asset types

* fix: Initialize IPFS client and check for mounted directories

* feat: Improve IPFS client initialization and mount checking

* feat: Add local filesystem check for IPFS and IPNS

* fix: Use Unixfs().Get() instead of Cat() for IPFS and IPNS content retrieval

* feat: Update GetCID and GetIPNS functions to read data from IPFS node

* fix: Ensure IPFS client is initialized before pinning CID

* feat: Add AddFile and AddFolder methods

* feat: add IPFS file system abstraction

* feat: Implement IPFS file, location, and filesystem abstractions

* refactor: remove unused functions and types

* refactor: remove unused FileSystem interface

* feat: add initial wasm entrypoint

* feat: add basic vault command operations

* docs: add vault module features

* test: remove test for MsgUpdateParams

* refactor: Replace PrimaryKey with Property struct in zkprop.go

* feat: Update the `CreateWitness` and `CreateAccumulator` and `VerifyWitness` and `UpdateAccumulator` to Use the new `Accumulator` and `Witness` types. Then Clean up the code in the file and refactor the marshalling methods

* <no value>

* feat: add KeyCurve and KeyType to KeyInfo in genesis

* feat: add WASM build step to devbox.json

* feat: Add zkgate.go file

* feat: Uncomment and modify zkgate code to work with Property struct

* feat: Merge zkgate.go and zkprop.go logic

* feat: implement API endpoints for profile management

* refactor: remove unused template file

* feat(orm): remove unused ORM models

* feat: add persistent SQLite database support in WASM

* fix: Update module names in protobuf files

* feat: Add method to initialize SQLite database

* fix: update go-sqlite3 dependency to version 1.14.23

* feat: introduce database layer

* feat: Implement database layer for Vault node

* feature/update-dockerfile

* feat: Add keyshares table

* fix: Reorder the SQL statements in the tables.go file

* feat: Update the `createCredentialsTable` method to match the proper Credential struct

* feat: Update createProfilesTable and add createPropertiesTable

* feat: Add constant SQL queries to queries.go and use prepared statements in db.go

* feat: Add createKeysharesTable to internal/db/db.go

* feat: Update `createPermissionsTable` to match Permissions struct

* feat: Add database enum types

* feat: Add DIDNamespace and PermissionScope enums

* feat: Add DBConfig and DBOption types

* feat: Update the db implementation to use the provided go library

* fix: update db implementation to use go-sqlite3 v0.18.2

* fix: Refactor database connection and statement handling

* feat: Simplify db.go implementation

* feat: Convert constant SQL queries to functions in queries.go and update db.go to use prepared statements

* feat: Add models.go file with database table structs

* fix: Remove unused statement map and prepare statements

diff --git a/internal/db/db.go b/internal/db/db.go
index 201d09b..d4d4d4e 100644
--- a/internal/db/db.go
+++ b/internal/db/db.go
@@ -32,11 +32,6 @@ func Open(config *DBConfig) (*DB, error) {
 		Conn: conn,
 	}

-	if err := createTables(db); err != nil {
-		conn.Close()
-		return nil, fmt.Errorf("failed to create tables: %w", err)
-	}
-
 	return db, nil
 }

@@ -61,114 +56,3 @@ func createTables(db *DB) error {
 	return nil
 }

-// AddAccount adds a new account to the database
-func (db *DB) AddAccount(name, address string) error {
-	return db.Exec(insertAccountQuery(name, address))
-}
-
-// AddAsset adds a new asset to the database
-func (db *DB) AddAsset(name, symbol string, decimals int, chainID int64) error {
-	return db.Exec(insertAssetQuery(name, symbol, decimals, chainID))
-}
-
-// AddChain adds a new chain to the database
-func (db *DB) AddChain(name, networkID string) error {
-	return db.Exec(insertChainQuery(name, networkID))
-}
-
-// AddCredential adds a new credential to the database
-func (db *DB) AddCredential(
-	handle, controller, attestationType, origin string,
-	credentialID, publicKey []byte,
-	transport string,
-	signCount uint32,
-	userPresent, userVerified, backupEligible, backupState, cloneWarning bool,
-) error {
-	return db.Exec(insertCredentialQuery(
-		handle,
-		controller,
-		attestationType,
-		origin,
-		credentialID,
-		publicKey,
-		transport,
-		signCount,
-		userPresent,
-		userVerified,
-		backupEligible,
-		backupState,
-		cloneWarning,
-	))
-}
-
-// AddProfile adds a new profile to the database
-func (db *DB) AddProfile(
-	id, subject, controller, originURI, publicMetadata, privateMetadata string,
-) error {
-	return db.statements["insertProfile"].Exec(
-		id, subject, controller, originURI, publicMetadata, privateMetadata,
-	)
-}
-
-// AddProperty adds a new property to the database
-func (db *DB) AddProperty(
-	profileID, key, accumulator, propertyKey string,
-) error {
-	return db.statements["insertProperty"].Exec(
-		profileID, key, accumulator, propertyKey,
-	)
-}
-
-// AddPermission adds a new permission to the database
-func (db *DB) AddPermission(
-	serviceID string,
-	grants []DIDNamespace,
-	scopes []PermissionScope,
-) error {
-	grantsJSON, err := json.Marshal(grants)
-	if err != nil {
-		return fmt.Errorf("failed to marshal grants: %w", err)
-	}
-
-	scopesJSON, err := json.Marshal(scopes)
-	if err != nil {
-		return fmt.Errorf("failed to marshal scopes: %w", err)
-	}
-
-	return db.statements["insertPermission"].Exec(
-		serviceID, string(grantsJSON), string(scopesJSON),
-	)
-}
-
-// GetPermission retrieves the permission for the given service ID
-func (db *DB) GetPermission(serviceID string) ([]DIDNamespace, []PermissionScope, error) {
-	row := db.statements["getPermission"].QueryRow(serviceID)
-
-	var grantsJSON, scopesJSON string
-	if err := row.Scan(&grantsJSON, &scopesJSON); err != nil {
-		return nil, nil, fmt.Errorf("failed to get permission: %w", err)
-	}
-
-	var grants []DIDNamespace
-	if err := json.Unmarshal([]byte(grantsJSON), &grants); err != nil {
-		return nil, nil, fmt.Errorf("failed to unmarshal grants: %w", err)
-	}
-
-	var scopes []PermissionScope
-	if err := json.Unmarshal([]byte(scopesJSON), &scopes); err != nil {
-		return nil, nil, fmt.Errorf("failed to unmarshal scopes: %w", err)
-	}
-
-	return grants, scopes, nil
-}
-
-// Close closes the database connection and finalizes all prepared statements
-func (db *DB) Close() error {
-	for _, stmt := range db.statements {
-		stmt.Finalize()
-	}
-	return db.Conn.Close()
-}
diff --git a/internal/db/queries.go b/internal/db/queries.go
index 807d701..e69de29 100644
--- a/internal/db/queries.go
+++ b/internal/db/queries.go
@@ -1,79 +0,0 @@
-package db
-
-import "fmt"
-
-// Account queries
-func insertAccountQuery(name, address string) string {
-	return fmt.Sprintf(`INSERT INTO accounts (name, address) VALUES (%s, %s)`, name, address)
-}
-
-// Asset queries
-func insertAssetQuery(name, symbol string, decimals int, chainID int64) string {
-	return fmt.Sprintf(
-		`INSERT INTO assets (name, symbol, decimals, chain_id) VALUES (%s, %s, %d, %d)`,
-		name,
-		symbol,
-		decimals,
-		chainID,
-	)
-}
-
-// Chain queries
-func insertChainQuery(name string, networkID string) string {
-	return fmt.Sprintf(`INSERT INTO chains (name, network_id) VALUES (%s, %d)`, name, networkID)
-}
-
-// Credential queries
-func insertCredentialQuery(
-	handle, controller, attestationType, origin string,
-	credentialID, publicKey []byte,
-	transport string,
-	signCount uint32,
-	userPresent, userVerified, backupEligible, backupState, cloneWarning bool,
-) string {
-	return fmt.Sprintf(`INSERT INTO credentials (
-		handle, controller, attestation_type, origin,
-		credential_id, public_key, transport, sign_count,
-		user_present, user_verified, backup_eligible,
-		backup_state, clone_warning
-	) VALUES (%s, %s, %s, %s, %s, %s, %s, %d, %t, %t, %t, %t, %t)`,
-		handle, controller, attestationType, origin,
-		credentialID, publicKey, transport, signCount,
-		userPresent, userVerified, backupEligible,
-		backupState, cloneWarning)
-}
-
-// Profile queries
-func insertProfileQuery(
-	id, subject, controller, originURI, publicMetadata, privateMetadata string,
-) string {
-	return fmt.Sprintf(`INSERT INTO profiles (
-		id, subject, controller, origin_uri,
-		public_metadata, private_metadata
-	) VALUES (%s, %s, %s, %s, %s, %s)`,
-		id, subject, controller, originURI,
-		publicMetadata, privateMetadata)
-}
-
-// Property queries
-func insertPropertyQuery(profileID, key, accumulator, propertyKey string) string {
-	return fmt.Sprintf(`INSERT INTO properties (
-		profile_id, key, accumulator, property_key
-	) VALUES (%s, %s, %s, %s)`,
-		profileID, key, accumulator, propertyKey)
-}
-
-// Permission queries
-func insertPermissionQuery(serviceID, grants, scopes string) string {
-	return fmt.Sprintf(
-		`INSERT INTO permissions (service_id, grants, scopes) VALUES (%s, %s, %s)`,
-		serviceID,
-		grants,
-		scopes,
-	)
-}
-
-// GetPermission query
-func getPermissionQuery(serviceID string) string {
-	return fmt.Sprintf(`SELECT grants, scopes FROM permissions WHERE service_id = %s`, serviceID)
-}

* fix: update Makefile to use sonrd instead of wasmd

* feat: Add targets for templ and vault in Makefile and use only make in devbox.json

* feat: add SQLite database support

* bump: version 0.6.0 → 0.7.0

* refactor: upgrade actions to latest versions

api/did/v1/state.cosmos_orm.go

@@ -17,6 +17,15 @@ type AssertionTable 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) (*Assertion, error)
+	HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error)
+	// GetBySubjectOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Assertion, error)
+	HasByControllerOrigin(ctx context.Context, controller string, origin string) (found bool, err error)
+	// GetByControllerOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByControllerOrigin(ctx context.Context, controller string, origin string) (*Assertion, error)
+	HasByControllerCredentialLabel(ctx context.Context, controller string, credential_label string) (found bool, err error)
+	// GetByControllerCredentialLabel returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByControllerCredentialLabel(ctx context.Context, controller string, credential_label string) (*Assertion, error)
 	List(ctx context.Context, prefixKey AssertionIndexKey, opts ...ormlist.Option) (AssertionIterator, error)
 	ListRange(ctx context.Context, from, to AssertionIndexKey, opts ...ormlist.Option) (AssertionIterator, error)
 	DeleteBy(ctx context.Context, prefixKey AssertionIndexKey) error
@@ -57,6 +66,60 @@ func (this AssertionIdIndexKey) WithId(id string) AssertionIdIndexKey {
 	return this
 }
 
+type AssertionSubjectOriginIndexKey struct {
+	vs []interface{}
+}
+
+func (x AssertionSubjectOriginIndexKey) id() uint32            { return 1 }
+func (x AssertionSubjectOriginIndexKey) values() []interface{} { return x.vs }
+func (x AssertionSubjectOriginIndexKey) assertionIndexKey()    {}
+
+func (this AssertionSubjectOriginIndexKey) WithSubject(subject string) AssertionSubjectOriginIndexKey {
+	this.vs = []interface{}{subject}
+	return this
+}
+
+func (this AssertionSubjectOriginIndexKey) WithSubjectOrigin(subject string, origin string) AssertionSubjectOriginIndexKey {
+	this.vs = []interface{}{subject, origin}
+	return this
+}
+
+type AssertionControllerOriginIndexKey struct {
+	vs []interface{}
+}
+
+func (x AssertionControllerOriginIndexKey) id() uint32            { return 2 }
+func (x AssertionControllerOriginIndexKey) values() []interface{} { return x.vs }
+func (x AssertionControllerOriginIndexKey) assertionIndexKey()    {}
+
+func (this AssertionControllerOriginIndexKey) WithController(controller string) AssertionControllerOriginIndexKey {
+	this.vs = []interface{}{controller}
+	return this
+}
+
+func (this AssertionControllerOriginIndexKey) WithControllerOrigin(controller string, origin string) AssertionControllerOriginIndexKey {
+	this.vs = []interface{}{controller, origin}
+	return this
+}
+
+type AssertionControllerCredentialLabelIndexKey struct {
+	vs []interface{}
+}
+
+func (x AssertionControllerCredentialLabelIndexKey) id() uint32            { return 3 }
+func (x AssertionControllerCredentialLabelIndexKey) values() []interface{} { return x.vs }
+func (x AssertionControllerCredentialLabelIndexKey) assertionIndexKey()    {}
+
+func (this AssertionControllerCredentialLabelIndexKey) WithController(controller string) AssertionControllerCredentialLabelIndexKey {
+	this.vs = []interface{}{controller}
+	return this
+}
+
+func (this AssertionControllerCredentialLabelIndexKey) WithControllerCredentialLabel(controller string, credential_label string) AssertionControllerCredentialLabelIndexKey {
+	this.vs = []interface{}{controller, credential_label}
+	return this
+}
+
 type assertionTable struct {
 	table ormtable.Table
 }
@@ -93,6 +156,72 @@ func (this assertionTable) Get(ctx context.Context, id string) (*Assertion, erro
 	return &assertion, nil
 }
 
+func (this assertionTable) HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error) {
+	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
+		subject,
+		origin,
+	)
+}
+
+func (this assertionTable) GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Assertion, error) {
+	var assertion Assertion
+	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &assertion,
+		subject,
+		origin,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &assertion, nil
+}
+
+func (this assertionTable) HasByControllerOrigin(ctx context.Context, controller string, origin string) (found bool, err error) {
+	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
+		controller,
+		origin,
+	)
+}
+
+func (this assertionTable) GetByControllerOrigin(ctx context.Context, controller string, origin string) (*Assertion, error) {
+	var assertion Assertion
+	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &assertion,
+		controller,
+		origin,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &assertion, nil
+}
+
+func (this assertionTable) HasByControllerCredentialLabel(ctx context.Context, controller string, credential_label string) (found bool, err error) {
+	return this.table.GetIndexByID(3).(ormtable.UniqueIndex).Has(ctx,
+		controller,
+		credential_label,
+	)
+}
+
+func (this assertionTable) GetByControllerCredentialLabel(ctx context.Context, controller string, credential_label string) (*Assertion, error) {
+	var assertion Assertion
+	found, err := this.table.GetIndexByID(3).(ormtable.UniqueIndex).Get(ctx, &assertion,
+		controller,
+		credential_label,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &assertion, nil
+}
+
 func (this assertionTable) List(ctx context.Context, prefixKey AssertionIndexKey, opts ...ormlist.Option) (AssertionIterator, error) {
 	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
 	return AssertionIterator{it}, err
@@ -134,6 +263,9 @@ type AttestationTable interface {
 	HasBySubjectOrigin(ctx context.Context, subject string, origin string) (found bool, err error)
 	// GetBySubjectOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
 	GetBySubjectOrigin(ctx context.Context, subject string, origin string) (*Attestation, error)
+	HasByControllerOrigin(ctx context.Context, controller string, origin string) (found bool, err error)
+	// GetByControllerOrigin returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByControllerOrigin(ctx context.Context, controller string, origin string) (*Attestation, error)
 	List(ctx context.Context, prefixKey AttestationIndexKey, opts ...ormlist.Option) (AttestationIterator, error)
 	ListRange(ctx context.Context, from, to AttestationIndexKey, opts ...ormlist.Option) (AttestationIterator, error)
 	DeleteBy(ctx context.Context, prefixKey AttestationIndexKey) error
@@ -192,6 +324,24 @@ func (this AttestationSubjectOriginIndexKey) WithSubjectOrigin(subject string, o
 	return this
 }
 
+type AttestationControllerOriginIndexKey struct {
+	vs []interface{}
+}
+
+func (x AttestationControllerOriginIndexKey) id() uint32            { return 2 }
+func (x AttestationControllerOriginIndexKey) values() []interface{} { return x.vs }
+func (x AttestationControllerOriginIndexKey) attestationIndexKey()  {}
+
+func (this AttestationControllerOriginIndexKey) WithController(controller string) AttestationControllerOriginIndexKey {
+	this.vs = []interface{}{controller}
+	return this
+}
+
+func (this AttestationControllerOriginIndexKey) WithControllerOrigin(controller string, origin string) AttestationControllerOriginIndexKey {
+	this.vs = []interface{}{controller, origin}
+	return this
+}
+
 type attestationTable struct {
 	table ormtable.Table
 }
@@ -250,6 +400,28 @@ func (this attestationTable) GetBySubjectOrigin(ctx context.Context, subject str
 	return &attestation, nil
 }
 
+func (this attestationTable) HasByControllerOrigin(ctx context.Context, controller string, origin string) (found bool, err error) {
+	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
+		controller,
+		origin,
+	)
+}
+
+func (this attestationTable) GetByControllerOrigin(ctx context.Context, controller string, origin string) (*Attestation, error) {
+	var attestation Attestation
+	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &attestation,
+		controller,
+		origin,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &attestation, nil
+}
+
 func (this attestationTable) List(ctx context.Context, prefixKey AttestationIndexKey, opts ...ormlist.Option) (AttestationIterator, error) {
 	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
 	return AttestationIterator{it}, err
@@ -288,6 +460,12 @@ type ControllerTable 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) (*Controller, error)
+	HasByAddress(ctx context.Context, address string) (found bool, err error)
+	// GetByAddress returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByAddress(ctx context.Context, address string) (*Controller, error)
+	HasByVaultCid(ctx context.Context, vault_cid string) (found bool, err error)
+	// GetByVaultCid returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByVaultCid(ctx context.Context, vault_cid string) (*Controller, error)
 	List(ctx context.Context, prefixKey ControllerIndexKey, opts ...ormlist.Option) (ControllerIterator, error)
 	ListRange(ctx context.Context, from, to ControllerIndexKey, opts ...ormlist.Option) (ControllerIterator, error)
 	DeleteBy(ctx context.Context, prefixKey ControllerIndexKey) error
@@ -328,6 +506,32 @@ func (this ControllerIdIndexKey) WithId(id string) ControllerIdIndexKey {
 	return this
 }
 
+type ControllerAddressIndexKey struct {
+	vs []interface{}
+}
+
+func (x ControllerAddressIndexKey) id() uint32            { return 1 }
+func (x ControllerAddressIndexKey) values() []interface{} { return x.vs }
+func (x ControllerAddressIndexKey) controllerIndexKey()   {}
+
+func (this ControllerAddressIndexKey) WithAddress(address string) ControllerAddressIndexKey {
+	this.vs = []interface{}{address}
+	return this
+}
+
+type ControllerVaultCidIndexKey struct {
+	vs []interface{}
+}
+
+func (x ControllerVaultCidIndexKey) id() uint32            { return 2 }
+func (x ControllerVaultCidIndexKey) values() []interface{} { return x.vs }
+func (x ControllerVaultCidIndexKey) controllerIndexKey()   {}
+
+func (this ControllerVaultCidIndexKey) WithVaultCid(vault_cid string) ControllerVaultCidIndexKey {
+	this.vs = []interface{}{vault_cid}
+	return this
+}
+
 type controllerTable struct {
 	table ormtable.Table
 }
@@ -364,6 +568,46 @@ func (this controllerTable) Get(ctx context.Context, id string) (*Controller, er
 	return &controller, nil
 }
 
+func (this controllerTable) HasByAddress(ctx context.Context, address string) (found bool, err error) {
+	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
+		address,
+	)
+}
+
+func (this controllerTable) GetByAddress(ctx context.Context, address string) (*Controller, error) {
+	var controller Controller
+	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &controller,
+		address,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &controller, nil
+}
+
+func (this controllerTable) HasByVaultCid(ctx context.Context, vault_cid string) (found bool, err error) {
+	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
+		vault_cid,
+	)
+}
+
+func (this controllerTable) GetByVaultCid(ctx context.Context, vault_cid string) (*Controller, error) {
+	var controller Controller
+	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &controller,
+		vault_cid,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &controller, nil
+}
+
 func (this controllerTable) List(ctx context.Context, prefixKey ControllerIndexKey, opts ...ormlist.Option) (ControllerIterator, error) {
 	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
 	return ControllerIterator{it}, err
@@ -402,6 +646,12 @@ type DelegationTable 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) (*Delegation, error)
+	HasByAccountAddressChainId(ctx context.Context, account_address string, chain_id string) (found bool, err error)
+	// GetByAccountAddressChainId returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByAccountAddressChainId(ctx context.Context, account_address string, chain_id string) (*Delegation, error)
+	HasByControllerAccountLabel(ctx context.Context, controller string, account_label string) (found bool, err error)
+	// GetByControllerAccountLabel returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByControllerAccountLabel(ctx context.Context, controller string, account_label string) (*Delegation, error)
 	List(ctx context.Context, prefixKey DelegationIndexKey, opts ...ormlist.Option) (DelegationIterator, error)
 	ListRange(ctx context.Context, from, to DelegationIndexKey, opts ...ormlist.Option) (DelegationIterator, error)
 	DeleteBy(ctx context.Context, prefixKey DelegationIndexKey) error
@@ -442,6 +692,60 @@ func (this DelegationIdIndexKey) WithId(id string) DelegationIdIndexKey {
 	return this
 }
 
+type DelegationAccountAddressChainIdIndexKey struct {
+	vs []interface{}
+}
+
+func (x DelegationAccountAddressChainIdIndexKey) id() uint32            { return 1 }
+func (x DelegationAccountAddressChainIdIndexKey) values() []interface{} { return x.vs }
+func (x DelegationAccountAddressChainIdIndexKey) delegationIndexKey()   {}
+
+func (this DelegationAccountAddressChainIdIndexKey) WithAccountAddress(account_address string) DelegationAccountAddressChainIdIndexKey {
+	this.vs = []interface{}{account_address}
+	return this
+}
+
+func (this DelegationAccountAddressChainIdIndexKey) WithAccountAddressChainId(account_address string, chain_id string) DelegationAccountAddressChainIdIndexKey {
+	this.vs = []interface{}{account_address, chain_id}
+	return this
+}
+
+type DelegationControllerAccountLabelIndexKey struct {
+	vs []interface{}
+}
+
+func (x DelegationControllerAccountLabelIndexKey) id() uint32            { return 2 }
+func (x DelegationControllerAccountLabelIndexKey) values() []interface{} { return x.vs }
+func (x DelegationControllerAccountLabelIndexKey) delegationIndexKey()   {}
+
+func (this DelegationControllerAccountLabelIndexKey) WithController(controller string) DelegationControllerAccountLabelIndexKey {
+	this.vs = []interface{}{controller}
+	return this
+}
+
+func (this DelegationControllerAccountLabelIndexKey) WithControllerAccountLabel(controller string, account_label string) DelegationControllerAccountLabelIndexKey {
+	this.vs = []interface{}{controller, account_label}
+	return this
+}
+
+type DelegationControllerChainIdIndexKey struct {
+	vs []interface{}
+}
+
+func (x DelegationControllerChainIdIndexKey) id() uint32            { return 3 }
+func (x DelegationControllerChainIdIndexKey) values() []interface{} { return x.vs }
+func (x DelegationControllerChainIdIndexKey) delegationIndexKey()   {}
+
+func (this DelegationControllerChainIdIndexKey) WithController(controller string) DelegationControllerChainIdIndexKey {
+	this.vs = []interface{}{controller}
+	return this
+}
+
+func (this DelegationControllerChainIdIndexKey) WithControllerChainId(controller string, chain_id string) DelegationControllerChainIdIndexKey {
+	this.vs = []interface{}{controller, chain_id}
+	return this
+}
+
 type delegationTable struct {
 	table ormtable.Table
 }
@@ -478,6 +782,50 @@ func (this delegationTable) Get(ctx context.Context, id string) (*Delegation, er
 	return &delegation, nil
 }
 
+func (this delegationTable) HasByAccountAddressChainId(ctx context.Context, account_address string, chain_id string) (found bool, err error) {
+	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
+		account_address,
+		chain_id,
+	)
+}
+
+func (this delegationTable) GetByAccountAddressChainId(ctx context.Context, account_address string, chain_id string) (*Delegation, error) {
+	var delegation Delegation
+	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &delegation,
+		account_address,
+		chain_id,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &delegation, nil
+}
+
+func (this delegationTable) HasByControllerAccountLabel(ctx context.Context, controller string, account_label string) (found bool, err error) {
+	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
+		controller,
+		account_label,
+	)
+}
+
+func (this delegationTable) GetByControllerAccountLabel(ctx context.Context, controller string, account_label string) (*Delegation, error) {
+	var delegation Delegation
+	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &delegation,
+		controller,
+		account_label,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &delegation, nil
+}
+
 func (this delegationTable) List(ctx context.Context, prefixKey DelegationIndexKey, opts ...ormlist.Option) (DelegationIterator, error) {
 	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
 	return DelegationIterator{it}, err
@@ -508,118 +856,197 @@ func NewDelegationTable(db ormtable.Schema) (DelegationTable, error) {
 	return delegationTable{table}, nil
 }
 
-type ServiceTable interface {
-	Insert(ctx context.Context, service *Service) error
-	Update(ctx context.Context, service *Service) error
-	Save(ctx context.Context, service *Service) error
-	Delete(ctx context.Context, service *Service) error
+type ServiceRecordTable interface {
+	Insert(ctx context.Context, serviceRecord *ServiceRecord) error
+	Update(ctx context.Context, serviceRecord *ServiceRecord) error
+	Save(ctx context.Context, serviceRecord *ServiceRecord) error
+	Delete(ctx context.Context, serviceRecord *ServiceRecord) error
 	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) (*Service, error)
-	List(ctx context.Context, prefixKey ServiceIndexKey, opts ...ormlist.Option) (ServiceIterator, error)
-	ListRange(ctx context.Context, from, to ServiceIndexKey, opts ...ormlist.Option) (ServiceIterator, error)
-	DeleteBy(ctx context.Context, prefixKey ServiceIndexKey) error
-	DeleteRange(ctx context.Context, from, to ServiceIndexKey) error
+	Get(ctx context.Context, id string) (*ServiceRecord, error)
+	HasByOriginUri(ctx context.Context, origin_uri string) (found bool, err error)
+	// GetByOriginUri returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByOriginUri(ctx context.Context, origin_uri string) (*ServiceRecord, error)
+	HasByControllerOriginUri(ctx context.Context, controller string, origin_uri string) (found bool, err error)
+	// GetByControllerOriginUri returns nil and an error which responds true to ormerrors.IsNotFound() if the record was not found.
+	GetByControllerOriginUri(ctx context.Context, controller string, origin_uri string) (*ServiceRecord, error)
+	List(ctx context.Context, prefixKey ServiceRecordIndexKey, opts ...ormlist.Option) (ServiceRecordIterator, error)
+	ListRange(ctx context.Context, from, to ServiceRecordIndexKey, opts ...ormlist.Option) (ServiceRecordIterator, error)
+	DeleteBy(ctx context.Context, prefixKey ServiceRecordIndexKey) error
+	DeleteRange(ctx context.Context, from, to ServiceRecordIndexKey) error
 
 	doNotImplement()
 }
 
-type ServiceIterator struct {
+type ServiceRecordIterator struct {
 	ormtable.Iterator
 }
 
-func (i ServiceIterator) Value() (*Service, error) {
-	var service Service
-	err := i.UnmarshalMessage(&service)
-	return &service, err
+func (i ServiceRecordIterator) Value() (*ServiceRecord, error) {
+	var serviceRecord ServiceRecord
+	err := i.UnmarshalMessage(&serviceRecord)
+	return &serviceRecord, err
 }
 
-type ServiceIndexKey interface {
+type ServiceRecordIndexKey interface {
 	id() uint32
 	values() []interface{}
-	serviceIndexKey()
+	serviceRecordIndexKey()
 }
 
 // primary key starting index..
-type ServicePrimaryKey = ServiceIdIndexKey
+type ServiceRecordPrimaryKey = ServiceRecordIdIndexKey
 
-type ServiceIdIndexKey struct {
+type ServiceRecordIdIndexKey struct {
 	vs []interface{}
 }
 
-func (x ServiceIdIndexKey) id() uint32            { return 0 }
-func (x ServiceIdIndexKey) values() []interface{} { return x.vs }
-func (x ServiceIdIndexKey) serviceIndexKey()      {}
+func (x ServiceRecordIdIndexKey) id() uint32             { return 0 }
+func (x ServiceRecordIdIndexKey) values() []interface{}  { return x.vs }
+func (x ServiceRecordIdIndexKey) serviceRecordIndexKey() {}
 
-func (this ServiceIdIndexKey) WithId(id string) ServiceIdIndexKey {
+func (this ServiceRecordIdIndexKey) WithId(id string) ServiceRecordIdIndexKey {
 	this.vs = []interface{}{id}
 	return this
 }
 
-type serviceTable struct {
+type ServiceRecordOriginUriIndexKey struct {
+	vs []interface{}
+}
+
+func (x ServiceRecordOriginUriIndexKey) id() uint32             { return 1 }
+func (x ServiceRecordOriginUriIndexKey) values() []interface{}  { return x.vs }
+func (x ServiceRecordOriginUriIndexKey) serviceRecordIndexKey() {}
+
+func (this ServiceRecordOriginUriIndexKey) WithOriginUri(origin_uri string) ServiceRecordOriginUriIndexKey {
+	this.vs = []interface{}{origin_uri}
+	return this
+}
+
+type ServiceRecordControllerOriginUriIndexKey struct {
+	vs []interface{}
+}
+
+func (x ServiceRecordControllerOriginUriIndexKey) id() uint32             { return 2 }
+func (x ServiceRecordControllerOriginUriIndexKey) values() []interface{}  { return x.vs }
+func (x ServiceRecordControllerOriginUriIndexKey) serviceRecordIndexKey() {}
+
+func (this ServiceRecordControllerOriginUriIndexKey) WithController(controller string) ServiceRecordControllerOriginUriIndexKey {
+	this.vs = []interface{}{controller}
+	return this
+}
+
+func (this ServiceRecordControllerOriginUriIndexKey) WithControllerOriginUri(controller string, origin_uri string) ServiceRecordControllerOriginUriIndexKey {
+	this.vs = []interface{}{controller, origin_uri}
+	return this
+}
+
+type serviceRecordTable struct {
 	table ormtable.Table
 }
 
-func (this serviceTable) Insert(ctx context.Context, service *Service) error {
-	return this.table.Insert(ctx, service)
+func (this serviceRecordTable) Insert(ctx context.Context, serviceRecord *ServiceRecord) error {
+	return this.table.Insert(ctx, serviceRecord)
 }
 
-func (this serviceTable) Update(ctx context.Context, service *Service) error {
-	return this.table.Update(ctx, service)
+func (this serviceRecordTable) Update(ctx context.Context, serviceRecord *ServiceRecord) error {
+	return this.table.Update(ctx, serviceRecord)
 }
 
-func (this serviceTable) Save(ctx context.Context, service *Service) error {
-	return this.table.Save(ctx, service)
+func (this serviceRecordTable) Save(ctx context.Context, serviceRecord *ServiceRecord) error {
+	return this.table.Save(ctx, serviceRecord)
 }
 
-func (this serviceTable) Delete(ctx context.Context, service *Service) error {
-	return this.table.Delete(ctx, service)
+func (this serviceRecordTable) Delete(ctx context.Context, serviceRecord *ServiceRecord) error {
+	return this.table.Delete(ctx, serviceRecord)
 }
 
-func (this serviceTable) Has(ctx context.Context, id string) (found bool, err error) {
+func (this serviceRecordTable) Has(ctx context.Context, id string) (found bool, err error) {
 	return this.table.PrimaryKey().Has(ctx, id)
 }
 
-func (this serviceTable) Get(ctx context.Context, id string) (*Service, error) {
-	var service Service
-	found, err := this.table.PrimaryKey().Get(ctx, &service, id)
+func (this serviceRecordTable) Get(ctx context.Context, id string) (*ServiceRecord, error) {
+	var serviceRecord ServiceRecord
+	found, err := this.table.PrimaryKey().Get(ctx, &serviceRecord, id)
 	if err != nil {
 		return nil, err
 	}
 	if !found {
 		return nil, ormerrors.NotFound
 	}
-	return &service, nil
+	return &serviceRecord, nil
 }
 
-func (this serviceTable) List(ctx context.Context, prefixKey ServiceIndexKey, opts ...ormlist.Option) (ServiceIterator, error) {
+func (this serviceRecordTable) HasByOriginUri(ctx context.Context, origin_uri string) (found bool, err error) {
+	return this.table.GetIndexByID(1).(ormtable.UniqueIndex).Has(ctx,
+		origin_uri,
+	)
+}
+
+func (this serviceRecordTable) GetByOriginUri(ctx context.Context, origin_uri string) (*ServiceRecord, error) {
+	var serviceRecord ServiceRecord
+	found, err := this.table.GetIndexByID(1).(ormtable.UniqueIndex).Get(ctx, &serviceRecord,
+		origin_uri,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &serviceRecord, nil
+}
+
+func (this serviceRecordTable) HasByControllerOriginUri(ctx context.Context, controller string, origin_uri string) (found bool, err error) {
+	return this.table.GetIndexByID(2).(ormtable.UniqueIndex).Has(ctx,
+		controller,
+		origin_uri,
+	)
+}
+
+func (this serviceRecordTable) GetByControllerOriginUri(ctx context.Context, controller string, origin_uri string) (*ServiceRecord, error) {
+	var serviceRecord ServiceRecord
+	found, err := this.table.GetIndexByID(2).(ormtable.UniqueIndex).Get(ctx, &serviceRecord,
+		controller,
+		origin_uri,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, ormerrors.NotFound
+	}
+	return &serviceRecord, nil
+}
+
+func (this serviceRecordTable) List(ctx context.Context, prefixKey ServiceRecordIndexKey, opts ...ormlist.Option) (ServiceRecordIterator, error) {
 	it, err := this.table.GetIndexByID(prefixKey.id()).List(ctx, prefixKey.values(), opts...)
-	return ServiceIterator{it}, err
+	return ServiceRecordIterator{it}, err
 }
 
-func (this serviceTable) ListRange(ctx context.Context, from, to ServiceIndexKey, opts ...ormlist.Option) (ServiceIterator, error) {
+func (this serviceRecordTable) ListRange(ctx context.Context, from, to ServiceRecordIndexKey, opts ...ormlist.Option) (ServiceRecordIterator, error) {
 	it, err := this.table.GetIndexByID(from.id()).ListRange(ctx, from.values(), to.values(), opts...)
-	return ServiceIterator{it}, err
+	return ServiceRecordIterator{it}, err
 }
 
-func (this serviceTable) DeleteBy(ctx context.Context, prefixKey ServiceIndexKey) error {
+func (this serviceRecordTable) DeleteBy(ctx context.Context, prefixKey ServiceRecordIndexKey) error {
 	return this.table.GetIndexByID(prefixKey.id()).DeleteBy(ctx, prefixKey.values()...)
 }
 
-func (this serviceTable) DeleteRange(ctx context.Context, from, to ServiceIndexKey) error {
+func (this serviceRecordTable) DeleteRange(ctx context.Context, from, to ServiceRecordIndexKey) error {
 	return this.table.GetIndexByID(from.id()).DeleteRange(ctx, from.values(), to.values())
 }
 
-func (this serviceTable) doNotImplement() {}
+func (this serviceRecordTable) doNotImplement() {}
 
-var _ ServiceTable = serviceTable{}
+var _ ServiceRecordTable = serviceRecordTable{}
 
-func NewServiceTable(db ormtable.Schema) (ServiceTable, error) {
-	table := db.GetTable(&Service{})
+func NewServiceRecordTable(db ormtable.Schema) (ServiceRecordTable, error) {
+	table := db.GetTable(&ServiceRecord{})
 	if table == nil {
-		return nil, ormerrors.TableNotFound.Wrap(string((&Service{}).ProtoReflect().Descriptor().FullName()))
+		return nil, ormerrors.TableNotFound.Wrap(string((&ServiceRecord{}).ProtoReflect().Descriptor().FullName()))
 	}
-	return serviceTable{table}, nil
+	return serviceRecordTable{table}, nil
 }
 
 type StateStore interface {
@@ -627,17 +1054,17 @@ type StateStore interface {
 	AttestationTable() AttestationTable
 	ControllerTable() ControllerTable
 	DelegationTable() DelegationTable
-	ServiceTable() ServiceTable
+	ServiceRecordTable() ServiceRecordTable
 
 	doNotImplement()
 }
 
 type stateStore struct {
-	assertion   AssertionTable
-	attestation AttestationTable
-	controller  ControllerTable
-	delegation  DelegationTable
-	service     ServiceTable
+	assertion     AssertionTable
+	attestation   AttestationTable
+	controller    ControllerTable
+	delegation    DelegationTable
+	serviceRecord ServiceRecordTable
 }
 
 func (x stateStore) AssertionTable() AssertionTable {
@@ -656,8 +1083,8 @@ func (x stateStore) DelegationTable() DelegationTable {
 	return x.delegation
 }
 
-func (x stateStore) ServiceTable() ServiceTable {
-	return x.service
+func (x stateStore) ServiceRecordTable() ServiceRecordTable {
+	return x.serviceRecord
 }
 
 func (stateStore) doNotImplement() {}
@@ -685,7 +1112,7 @@ func NewStateStore(db ormtable.Schema) (StateStore, error) {
 		return nil, err
 	}
 
-	serviceTable, err := NewServiceTable(db)
+	serviceRecordTable, err := NewServiceRecordTable(db)
 	if err != nil {
 		return nil, err
 	}
@@ -695,6 +1122,6 @@ func NewStateStore(db ormtable.Schema) (StateStore, error) {
 		attestationTable,
 		controllerTable,
 		delegationTable,
-		serviceTable,
+		serviceRecordTable,
 	}, nil
 }