feature/ipfs vault allocation (#8)

* refactor: move constants to genesis.proto

* feat: add ipfs_active flag to genesis state

* feat: add IPFS connection initialization to keeper

* feat: add testnet process-compose

* refactor: rename sonr-testnet docker image to sonr-runner

* refactor: update docker-vm-release workflow to use 'latest' tag

* feat: add permission to workflows

* feat: add new service chain execution

* feat: add abstract vault class to pkl

* feat: use jetpackio/devbox image for runner

* feat: introduce dwn for local service worker

* refactor: remove unnecessary dockerfile layers

* refactor(deploy): Update Dockerfile to copy go.mod and go.sum from the parent directory

* build: move Dockerfile to root directory

* build: Add Dockerfile for deployment

* feat: Update Dockerfile to work with Go project in parent directory

* build: Update docker-compose.yaml to use relative paths

* feat: Update docker-compose to work with new image and parent git directory

* refactor: remove unnecessary test script

* <no value>

* feat: add test_node script for running node tests

* feat: add IPFS cluster to testnet

* feat: add docker image for sonr-runner

* fix: typo in export path

* feat(did): Add Localhost Registration Enabled Genesis Option

* feat: add support for Sqlite DB in vault

* feat: improve vault model JSON serialization

* feat: support querying HTMX endpoint for DID

* feat: Add primary key, unique, default, not null, auto increment, and foreign key field types

* feat: Add PublicKey model in pkl/vault.pkl

* feat: add frontend server

* refactor: move dwn.wasm to vfs directory

* feat(frontend): remove frontend server implementation

* feat: Add a frontend server and web auth protocol

* feat: implement new key types for MPC and ZK proofs

* fix: Update enum types and DefaultKeyInfos

* fix: correct typo in KeyAlgorithm enum

* feat(did): add attestation format validation

* feat: Add x/did/builder/extractor.go

* feat: Update JWK parsing in x/did/builder/extractor.go

* feat: Use github.com/onsonr/sonr/x/did/types package

* feat: Extract and format public keys from WebAuthn credentials

* feat: Introduce a new `mapToJWK` function to convert a map to a `types.JWK` struct

* feat: add support for extracting JWK public keys

* feat: remove VerificationMethod struct

* refactor: extract public key extraction logic

* feat: add helper functions to map COSECurveID to JWK curve names

* feat: pin initial vault

x/did/keeper/genesis.go

@@ -2,8 +2,11 @@ package keeper
 
 import (
 	"context"
+	"time"
 
 	"cosmossdk.io/log"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
 	"github.com/onsonr/sonr/x/did/types"
 )
 
@@ -35,3 +38,38 @@ func (k *Keeper) ExportGenesis(ctx context.Context) *types.GenesisState {
 		Params: params,
 	}
 }
+
+// CheckValidatorExists checks if a validator exists
+func (k Keeper) CheckValidatorExists(ctx sdk.Context, addr string) bool {
+	address, err := sdk.ValAddressFromBech32(addr)
+	if err != nil {
+		return false
+	}
+	ok, err := k.StakingKeeper.Validator(ctx, address)
+	if err != nil {
+		return false
+	}
+	if ok != nil {
+		return true
+	}
+	return false
+}
+
+// GetAverageBlockTime returns the average block time in seconds
+func (k Keeper) GetAverageBlockTime(ctx sdk.Context) float64 {
+	return float64(ctx.BlockTime().Sub(ctx.BlockTime()).Seconds())
+}
+
+// GetParams returns the module parameters.
+func (k Keeper) GetParams(ctx sdk.Context) *types.Params {
+	p, err := k.Params.Get(ctx)
+	if err != nil {
+		p = types.DefaultParams()
+	}
+	return &p
+}
+
+// GetExpirationBlockHeight returns the block height at which the given duration will have passed
+func (k Keeper) GetExpirationBlockHeight(ctx sdk.Context, duration time.Duration) int64 {
+	return ctx.BlockHeight() + int64(duration.Seconds()/k.GetAverageBlockTime(ctx))
+}

x/did/keeper/ipfs.go

@@ -1,32 +1,82 @@
 package keeper
 
 import (
+	"context"
+	"fmt"
+	"time"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/ipfs/boxo/files"
 	"github.com/ipfs/boxo/path"
+	"github.com/ipfs/kubo/client/rpc"
 	"github.com/ipfs/kubo/core/coreiface/options"
+	"github.com/onsonr/sonr/internal/vfs"
 )
 
-// AddToLocalIPFS adds a file to the local IPFS node
-func (k Keeper) AddToLocalIPFS(ctx sdk.Context, data files.Node) (string, error) {
-	cid, err := k.ipfsClient.Unixfs().Add(ctx, data)
+// assembleInitialVault assembles the initial vault
+func (k Keeper) assembleInitialVault(ctx sdk.Context) (string, int64, error) {
+	cid, err := k.ipfsClient.Unixfs().Add(context.Background(), vfs.AssembleDirectory())
 	if err != nil {
-		return "", err
+		return "", 0, err
 	}
-	return cid.String(), nil
+	return cid.String(), k.GetExpirationBlockHeight(ctx, time.Second*15), nil
 }
 
-// GetFromLocalIPFS gets a file from the local IPFS node
-func (k Keeper) GetFromLocalIPFS(ctx sdk.Context, cid string) (files.Node, error) {
+// pinInitialVault pins the initial vault to the local IPFS node
+func (k Keeper) pinInitialVault(_ sdk.Context, cid string, address string) error {
+	// Resolve the path
+	path, err := path.NewPath(cid)
+	if err != nil {
+		return err
+	}
+
+	// 1. Initialize vault.db sqlite database in local IPFS with Mount
+
+	// 2. Insert the InitialWalletAccounts
+
+	// 3. Publish the path to the IPNS
+	_, err = k.ipfsClient.Name().Publish(context.Background(), path, options.Name.Key(address))
+	if err != nil {
+		return err
+	}
+
+	// 4. Insert the accounts into x/auth
+
+	// 5. Insert the controller into state
+	return nil
+}
+
+// GetFromIPFS gets a file from the local IPFS node
+func (k Keeper) GetFromIPFS(ctx sdk.Context, cid string) (files.Directory, error) {
 	path, err := path.NewPath(cid)
 	if err != nil {
 		return nil, err
 	}
-	return k.ipfsClient.Unixfs().Get(ctx, path)
+	node, err := k.ipfsClient.Unixfs().Get(ctx, path)
+	if err != nil {
+		return nil, err
+	}
+	dir, ok := node.(files.Directory)
+	if !ok {
+		return nil, fmt.Errorf("retrieved node is not a directory")
+	}
+	return dir, nil
 }
 
-// HasPathInLocalIPFS checks if a file is in the local IPFS node
-func (k Keeper) HasPathInLocalIPFS(ctx sdk.Context, cid string) (bool, error) {
+// HasIPFSConnection returns true if the IPFS client is initialized
+func (k *Keeper) HasIPFSConnection() bool {
+	if k.ipfsClient == nil {
+		ipfsClient, err := rpc.NewLocalApi()
+		if err != nil {
+			return false
+		}
+		k.ipfsClient = ipfsClient
+	}
+	return k.ipfsClient != nil
+}
+
+// HasPathInIPFS checks if a file is in the local IPFS node
+func (k Keeper) HasPathInIPFS(ctx sdk.Context, cid string) (bool, error) {
 	path, err := path.NewPath(cid)
 	if err != nil {
 		return false, err
@@ -42,8 +92,8 @@ func (k Keeper) HasPathInLocalIPFS(ctx sdk.Context, cid string) (bool, error) {
 	return true, nil
 }
 
-// PinToLocalIPFS pins a file to the local IPFS node
-func (k Keeper) PinToLocalIPFS(ctx sdk.Context, cid string, name string) error {
+// PinToIPFS pins a file to the local IPFS node
+func (k Keeper) PinToIPFS(ctx sdk.Context, cid string, name string) error {
 	path, err := path.NewPath(cid)
 	if err != nil {
 		return err

x/did/keeper/keeper.go

@@ -6,6 +6,7 @@ import (
 	"cosmossdk.io/log"
 	"cosmossdk.io/orm/model/ormdb"
 	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
@@ -13,6 +14,7 @@ import (
 	"github.com/ipfs/kubo/client/rpc"
 
 	apiv1 "github.com/onsonr/sonr/api/did/v1"
+	middleware "github.com/onsonr/sonr/x/did/middleware"
 	"github.com/onsonr/sonr/x/did/types"
 )
 
@@ -35,13 +37,23 @@ type Keeper struct {
 }
 
 // NewKeeper creates a new poa Keeper instance
-func NewKeeper(cdc codec.BinaryCodec, storeService storetypes.KVStoreService, accKeeper authkeeper.AccountKeeper, stkKeeper *stakkeeper.Keeper, logger log.Logger, authority string) Keeper {
+func NewKeeper(
+	cdc codec.BinaryCodec,
+	storeService storetypes.KVStoreService,
+	accKeeper authkeeper.AccountKeeper,
+	stkKeeper *stakkeeper.Keeper,
+	logger log.Logger,
+	authority string,
+) Keeper {
 	logger = logger.With(log.ModuleKey, "x/"+types.ModuleName)
 	sb := collections.NewSchemaBuilder(storeService)
 	if authority == "" {
 		authority = authtypes.NewModuleAddress(govtypes.ModuleName).String()
 	}
-	db, err := ormdb.NewModuleDB(&types.ORMModuleSchema, ormdb.ModuleDBOptions{KVStoreService: storeService})
+	db, err := ormdb.NewModuleDB(
+		&types.ORMModuleSchema,
+		ormdb.ModuleDBOptions{KVStoreService: storeService},
+	)
 	if err != nil {
 		panic(err)
 	}
@@ -53,10 +65,15 @@ func NewKeeper(cdc codec.BinaryCodec, storeService storetypes.KVStoreService, ac
 	// Initialize IPFS client
 	ipfsClient, _ := rpc.NewLocalApi()
 	k := Keeper{
-		ipfsClient:    ipfsClient,
-		cdc:           cdc,
-		logger:        logger,
-		Params:        collections.NewItem(sb, types.ParamsKey, "params", codec.CollValue[types.Params](cdc)),
+		ipfsClient: ipfsClient,
+		cdc:        cdc,
+		logger:     logger,
+		Params: collections.NewItem(
+			sb,
+			types.ParamsKey,
+			"params",
+			codec.CollValue[types.Params](cdc),
+		),
 		authority:     authority,
 		OrmDB:         store,
 		AccountKeeper: accKeeper,
@@ -71,7 +88,53 @@ func NewKeeper(cdc codec.BinaryCodec, storeService storetypes.KVStoreService, ac
 	return k
 }
 
-// HasIPFSConnection returns true if the IPFS client is initialized
-func (k *Keeper) HasIPFSConnection() bool {
-	return k.ipfsClient != nil
+// IsClaimedServiceOrigin checks if a service origin is unclaimed
+func (k Keeper) IsUnclaimedServiceOrigin(ctx sdk.Context, origin string) bool {
+	rec, _ := k.OrmDB.ServiceRecordTable().GetByOriginUri(ctx, origin)
+	return rec == nil
+}
+
+// IsValidServiceOrigin checks if a service origin is valid
+func (k Keeper) IsValidServiceOrigin(ctx sdk.Context, origin string, clientInfo *middleware.ClientInfo) bool {
+	if origin != clientInfo.Hostname {
+		return false
+	}
+	rec, err := k.OrmDB.ServiceRecordTable().GetByOriginUri(ctx, origin)
+	if err != nil {
+		return false
+	}
+	if rec == nil {
+		return false
+	}
+	return true
+}
+
+// VerifyMinimumStake checks if a validator has a minimum stake
+func (k Keeper) VerifyMinimumStake(ctx sdk.Context, addr string) bool {
+	address, err := sdk.AccAddressFromBech32(addr)
+	if err != nil {
+		return false
+	}
+	addval, err := sdk.ValAddressFromBech32(addr)
+	if err != nil {
+		return false
+	}
+	del, err := k.StakingKeeper.GetDelegation(ctx, address, addval)
+	if err != nil {
+		return false
+	}
+	if del.Shares.IsZero() {
+		return false
+	}
+	return del.Shares.IsPositive()
+}
+
+// VerifyServicePermissions checks if a service has permission
+func (k Keeper) VerifyServicePermissions(
+	ctx sdk.Context,
+	addr string,
+	service string,
+	permissions string,
+) bool {
+	return false
 }

x/did/keeper/models.go

@@ -0,0 +1,12 @@
+package keeper
+
+import (
+	didv1 "github.com/onsonr/sonr/api/did/v1"
+	"github.com/onsonr/sonr/x/did/types"
+)
+
+func convertServiceRecord(rec *didv1.ServiceRecord) *types.Service {
+	return &types.Service{
+		Origin: rec.OriginUri,
+	}
+}

x/did/keeper/querier.go

@@ -2,8 +2,11 @@ package keeper
 
 import (
 	"context"
+	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/genproto/googleapis/api/httpbody"
+	"google.golang.org/grpc/peer"
 
 	"github.com/onsonr/sonr/x/did/types"
 )
@@ -19,43 +22,53 @@ func NewQuerier(keeper Keeper) Querier {
 }
 
 // Params returns the total set of did parameters.
-func (k Querier) Params(c context.Context, req *types.QueryRequest) (*types.QueryParamsResponse, error) {
+func (k Querier) Params(
+	c context.Context,
+	req *types.QueryRequest,
+) (*types.QueryParamsResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
 
 	p, err := k.Keeper.Params.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-
-	return &types.QueryParamsResponse{Params: &p, IpfsActive: k.HasIPFSConnection()}, nil
-}
-
-// Accounts implements types.QueryServer.
-func (k Querier) Accounts(goCtx context.Context, req *types.QueryRequest) (*types.QueryAccountsResponse, error) {
-	// ctx := sdk.UnwrapSDKContext(goCtx)
-	return &types.QueryAccountsResponse{}, nil
-}
-
-// Credentials implements types.QueryServer.
-func (k Querier) Credentials(goCtx context.Context, req *types.QueryRequest) (*types.QueryCredentialsResponse, error) {
-	// ctx := sdk.UnwrapSDKContext(goCtx)
-	return &types.QueryCredentialsResponse{}, nil
+	params := p.ActiveParams(k.HasIPFSConnection())
+	return &types.QueryParamsResponse{Params: &params}, nil
 }
 
 // Resolve implements types.QueryServer.
-func (k Querier) Resolve(goCtx context.Context, req *types.QueryRequest) (*types.QueryResolveResponse, error) {
+func (k Querier) Resolve(
+	goCtx context.Context,
+	req *types.QueryRequest,
+) (*types.QueryResolveResponse, error) {
 	// ctx := sdk.UnwrapSDKContext(goCtx)
 	return &types.QueryResolveResponse{}, nil
 }
 
 // Service implements types.QueryServer.
-func (k Querier) Service(goCtx context.Context, req *types.QueryRequest) (*types.QueryServiceResponse, error) {
-	// ctx := sdk.UnwrapSDKContext(goCtx)
-	return &types.QueryServiceResponse{}, nil
+func (k Querier) Service(
+	goCtx context.Context,
+	req *types.QueryRequest,
+) (*types.QueryServiceResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	_, ok := peer.FromContext(goCtx)
+	if !ok {
+		return nil, fmt.Errorf("failed to get peer from context")
+	}
+
+	rec, err := k.OrmDB.ServiceRecordTable().GetByOriginUri(ctx, req.Origin)
+	if err != nil {
+		return nil, err
+	}
+	return &types.QueryServiceResponse{Service: convertServiceRecord(rec)}, nil
 }
 
-// Token implements types.QueryServer.
-func (k Querier) Token(goCtx context.Context, req *types.QueryRequest) (*types.QueryTokenResponse, error) {
+// HTMX implements types.QueryServer.
+func (k Querier) HTMX(goCtx context.Context, req *types.QueryRequest) (*httpbody.HttpBody, error) {
 	// ctx := sdk.UnwrapSDKContext(goCtx)
-	return &types.QueryTokenResponse{}, nil
+	return &httpbody.HttpBody{
+		ContentType: "text/html",
+		Data:        []byte("<html><body>HTMX</body></html>"),
+	}, nil
 }

x/did/keeper/server.go

@@ -2,13 +2,14 @@ package keeper
 
 import (
 	"context"
+	"encoding/json"
 
+	"cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 
-	"cosmossdk.io/errors"
-	didv1 "github.com/onsonr/sonr/api/did/v1"
-	"github.com/onsonr/sonr/internal/files"
+	"github.com/onsonr/sonr/x/did/builder"
+	"github.com/onsonr/sonr/x/did/middleware"
 	"github.com/onsonr/sonr/x/did/types"
 )
 
@@ -24,62 +25,111 @@ func NewMsgServerImpl(keeper Keeper) types.MsgServer {
 }
 
 // UpdateParams updates the x/did module parameters.
-func (ms msgServer) UpdateParams(ctx context.Context, msg *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
+func (ms msgServer) UpdateParams(
+	ctx context.Context,
+	msg *types.MsgUpdateParams,
+) (*types.MsgUpdateParamsResponse, error) {
 	if ms.k.authority != msg.Authority {
-		return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.k.authority, msg.Authority)
+		return nil, errors.Wrapf(
+			govtypes.ErrInvalidSigner,
+			"invalid authority; expected %s, got %s",
+			ms.k.authority,
+			msg.Authority,
+		)
 	}
 
 	return nil, ms.k.Params.Set(ctx, msg.Params)
 }
 
 // Authorize implements types.MsgServer.
-func (ms msgServer) Authorize(ctx context.Context, msg *types.MsgAuthorize) (*types.MsgAuthorizeResponse, error) {
+func (ms msgServer) Authorize(
+	ctx context.Context,
+	msg *types.MsgAuthorize,
+) (*types.MsgAuthorizeResponse, error) {
 	if ms.k.authority != msg.Authority {
-		return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.k.authority, msg.Authority)
+		return nil, errors.Wrapf(
+			govtypes.ErrInvalidSigner,
+			"invalid authority; expected %s, got %s",
+			ms.k.authority,
+			msg.Authority,
+		)
 	}
 	// ctx := sdk.UnwrapSDKContext(goCtx)
 	return &types.MsgAuthorizeResponse{}, nil
 }
 
 // AllocateVault implements types.MsgServer.
-func (ms msgServer) AllocateVault(goCtx context.Context, msg *types.MsgAllocateVault) (*types.MsgAllocateVaultResponse, error) {
-	//	ctx := sdk.UnwrapSDKContext(goCtx)
-	err := files.Assemble("/tmp/sonr-testnet-1/vaults/0")
+func (ms msgServer) AllocateVault(
+	goCtx context.Context,
+	msg *types.MsgAllocateVault,
+) (*types.MsgAllocateVaultResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	clientInfo, err := middleware.ExtractClientInfo(goCtx)
 	if err != nil {
 		return nil, err
 	}
-	return &types.MsgAllocateVaultResponse{}, nil
+
+	// 1.Check if the service origin is valid
+	if ms.k.IsValidServiceOrigin(ctx, msg.Origin, clientInfo) {
+		return nil, types.ErrInvalidServiceOrigin
+	}
+
+	cid, expiryBlock, err := ms.k.assembleInitialVault(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	regOpts, err := builder.NewRegistrationOptions(msg.Origin, msg.Subject, cid, ms.k.GetParams(ctx))
+	if err != nil {
+		return nil, err
+	}
+
+	// Convert to string
+	regOptsJSON, err := json.Marshal(regOpts)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.MsgAllocateVaultResponse{
+		ExpiryBlock:         expiryBlock,
+		Cid:                 cid,
+		RegistrationOptions: string(regOptsJSON),
+	}, nil
 }
 
 // RegisterController implements types.MsgServer.
-func (ms msgServer) RegisterController(goCtx context.Context, msg *types.MsgRegisterController) (*types.MsgRegisterControllerResponse, error) {
-	if ms.k.authority != msg.Authority {
-		return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.k.authority, msg.Authority)
-	}
-	ctx := sdk.UnwrapSDKContext(goCtx)
-	svc := didv1.ServiceRecord{
-		Controller: msg.Authority,
-	}
-	ms.k.OrmDB.ServiceRecordTable().Insert(ctx, &svc)
+func (ms msgServer) RegisterController(
+	goCtx context.Context,
+	msg *types.MsgRegisterController,
+) (*types.MsgRegisterControllerResponse, error) {
+	_ = sdk.UnwrapSDKContext(goCtx)
 	return &types.MsgRegisterControllerResponse{}, nil
 }
 
 // RegisterService implements types.MsgServer.
-func (ms msgServer) RegisterService(ctx context.Context, msg *types.MsgRegisterService) (*types.MsgRegisterServiceResponse, error) {
-	if ms.k.authority != msg.Controller {
-		return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.k.authority, msg.Controller)
+func (ms msgServer) RegisterService(
+	goCtx context.Context,
+	msg *types.MsgRegisterService,
+) (*types.MsgRegisterServiceResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	clientInfo, err := middleware.ExtractClientInfo(goCtx)
+	if err != nil {
+		return nil, err
 	}
 
-	// ctx := sdk.UnwrapSDKContext(goCtx)
-	svc := didv1.ServiceRecord{
-		Controller: msg.Controller,
+	// 1.Check if the service origin is valid
+	if !ms.k.IsValidServiceOrigin(ctx, msg.OriginUri, clientInfo) {
+		return nil, types.ErrInvalidServiceOrigin
 	}
-	ms.k.OrmDB.ServiceRecordTable().Insert(ctx, &svc)
-	return &types.MsgRegisterServiceResponse{}, nil
+	return ms.k.insertService(ctx, msg)
 }
 
 // SyncVault implements types.MsgServer.
-func (ms msgServer) SyncVault(ctx context.Context, msg *types.MsgSyncVault) (*types.MsgSyncVaultResponse, error) {
+func (ms msgServer) SyncVault(
+	ctx context.Context,
+	msg *types.MsgSyncVault,
+) (*types.MsgSyncVaultResponse, error) {
 	// ctx := sdk.UnwrapSDKContext(goCtx)
 	return &types.MsgSyncVaultResponse{}, nil
 }

x/did/keeper/state.go

@@ -0,0 +1,26 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	didv1 "github.com/onsonr/sonr/api/did/v1"
+	"github.com/onsonr/sonr/x/did/types"
+)
+
+// insertService inserts a service record into the database
+func (k Keeper) insertService(
+	ctx sdk.Context,
+	svc *types.MsgRegisterService,
+) (*types.MsgRegisterServiceResponse, error) {
+	record := didv1.ServiceRecord{
+		Id: svc.OriginUri,
+	}
+	err := k.OrmDB.ServiceRecordTable().Insert(ctx, &record)
+	if err != nil {
+		return nil, err
+	}
+	return &types.MsgRegisterServiceResponse{
+		Success: true,
+		Did:     record.Id,
+	}, nil
+}

x/did/keeper/validate.go

@@ -1,70 +0,0 @@
-package keeper
-
-import (
-	"time"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-)
-
-// CheckValidatorExists checks if a validator exists
-func (k Keeper) CheckValidatorExists(ctx sdk.Context, addr string) bool {
-	address, err := sdk.ValAddressFromBech32(addr)
-	if err != nil {
-		return false
-	}
-	ok, err := k.StakingKeeper.Validator(ctx, address)
-	if err != nil {
-		return false
-	}
-	if ok != nil {
-		return true
-	}
-	return false
-}
-
-// GetAverageBlockTime returns the average block time in seconds
-func (k Keeper) GetAverageBlockTime(ctx sdk.Context) float64 {
-	return float64(ctx.BlockTime().Sub(ctx.BlockTime()).Seconds())
-}
-
-// GetExpirationBlockHeight returns the block height at which the given duration will have passed
-func (k Keeper) GetExpirationBlockHeight(ctx sdk.Context, duration time.Duration) int64 {
-	return ctx.BlockHeight() + int64(duration.Seconds()/k.GetAverageBlockTime(ctx))
-}
-
-// ValidServiceOrigin checks if a service origin is valid
-func (k Keeper) ValidServiceOrigin(ctx sdk.Context, origin string) bool {
-	rec, err := k.OrmDB.ServiceRecordTable().GetByOriginUri(ctx, origin)
-	if err != nil {
-		return false
-	}
-	if rec == nil {
-		return false
-	}
-	return true
-}
-
-// VerifyMinimumStake checks if a validator has a minimum stake
-func (k Keeper) VerifyMinimumStake(ctx sdk.Context, addr string) bool {
-	address, err := sdk.AccAddressFromBech32(addr)
-	if err != nil {
-		return false
-	}
-	addval, err := sdk.ValAddressFromBech32(addr)
-	if err != nil {
-		return false
-	}
-	del, err := k.StakingKeeper.GetDelegation(ctx, address, addval)
-	if err != nil {
-		return false
-	}
-	if del.Shares.IsZero() {
-		return false
-	}
-	return del.Shares.IsPositive()
-}
-
-// VerifyServicePermissions checks if a service has permission
-func (k Keeper) VerifyServicePermissions(ctx sdk.Context, addr string, service string, permissions string) bool {
-	return false
-}