feature/implement vault allocation (#11)

* feat: add authentication middleware

* feat: add REST API endpoints for database interactions

* refactor: move DiscoveryDocument Pkl schema to oidc module

* fix: replace sonrd with test_node.sh

* feat: use NFT keeper to mint DID namespace NFT

* refactor: move NFT class configuration to types

* feat: add GlobalIntegrity genesis state

* fix: ensure GlobalIntegrity is initialized in genesis

* refactor: update all references to transactions module

* refactor: improve genesis state struct

* chore(did): update discovery endpoint to reflect base url

* feat: remove unused context cache and client code

* refactor: remove middleware dependency from keeper

* feat: Add new query handlers for DID module

* feat: Implement unimplemented params queries

* feat: add support for first-party caveats

* refactor: move motr command to cmd directory

* feat: add support for GitHub releases

* fix(motr): build app.wasm for motr package

* feat: add card component

* feat: add IndexedDB support for persistent storage

* feat: Add Row and Column components

* feat: add  and  components

* refactor: improve button component

* refactor: remove unnecessary button parameter in renderButton

* feat: add vault service endpoint

* feat: add input component

internal/db/database.go

@@ -1,17 +1,54 @@
 package db
 
-import "gorm.io/gorm"
+import (
+	"crypto/rand"
+
+	"github.com/ncruces/go-sqlite3/gormlite"
+	"golang.org/x/crypto/argon2"
+	"gorm.io/gorm"
+	"lukechampine.com/adiantum/hbsh"
+	"lukechampine.com/adiantum/hpolyc"
+)
 
 type DB struct {
 	*gorm.DB
 }
 
-func New(opts ...DBOption) *DBConfig {
+func New(opts ...DBOption) (*DB, error) {
 	config := &DBConfig{
 		fileName: "vault.db",
 	}
 	for _, opt := range opts {
 		opt(config)
 	}
-	return config
+	gormdb, err := gorm.Open(gormlite.Open(config.ConnectionString()))
+	if err != nil {
+		return nil, err
+	}
+	db, err := createInitialTables(gormdb)
+	if err != nil {
+		return nil, err
+	}
+	return db, nil
+}
+
+// HBSH creates an HBSH cipher given a key.
+func (c *DB) HBSH(key []byte) *hbsh.HBSH {
+	if len(key) != 32 {
+		// Key is not appropriate, return nil.
+		return nil
+	}
+	return hpolyc.New(key)
+}
+
+// KDF gets a key from a secret.
+func (c *DB) KDF(secret string) []byte {
+	if secret == "" {
+		// No secret is given, generate a random key.
+		key := make([]byte, 32)
+		n, _ := rand.Read(key)
+		return key[:n]
+	}
+	// Hash the secret with a KDF.
+	return argon2.IDKey([]byte(secret), []byte("hpolyc"), 3, 64*1024, 4, 32)
 }