feature/simplify ucan mpc did (#1195)

* feat: enable DID auth middleware

* feat: implement passkey creation flow

* feat: persist user address in cookie and retrieve user profile using address cookie

* feat: implement human verification challenge during session initialization

* refactor: remove unnecessary random number generation in profile creation

* refactor: rename credential validation handler and update related routes

* feat: improve profile validation and user experience

* feat: add page rendering for profile and passkey creation

* refactor: remove unused register handler and update routes

* refactor: remove unused imports and simplify credential validation

* fix: Correct insecure gRPC client connection

* refactor: rename models files for better organization

* refactor: refactor grpc client creation and management

* refactor: refactor common clients package

* <no value>

* feat: add CapAccount, CapInterchain, CapVault enums

* feat: add ChainId to ResAccount and ResInterchain

* feat: add asset code to resource account enumeration

* refactor: rename services package to providers

* feat: implement gateway database interactions

* refactor: move gateway repository to internal/gateway

* refactor: Migrate database provider to use sqlx

* refactor: Rename Vaults to VaultProvider in HTTPContext struct

* refactor: Migrate from GORM to sqlc Queries in database context methods

* refactor: Replace GORM with standard SQL and simplify database initialization

* refactor: Migrate session management from GORM to sqlc with type conversion

* refactor: Update import paths and model references in context package

* fix: Resolve session type conversion and middleware issues

* refactor: Migrate database from GORM to sqlx

* refactor: Move models to pkg/common, improve code structure

* refactor: move repository package to internal directory

* refactor: move gateway internal packages to context directory

* refactor: migrate database provider to use sqlx queries

* feat: add session ID to HTTP context and use it to load session data

* feat: implement vault creation API endpoint

* feat: add DIDKey generation from PubKey

* refactor: remove unused DIDAuth components

* refactor: move DID auth controller to vault context

* chore: remove unused DIDAuth package

* refactor: improve clarity of enclave refresh function

* feat: implement nonce-based key encryption for improved security

* feat: Add Export and Import methods with comprehensive tests for Enclave

* fix: Validate AES key length in keyshare encryption and decryption

* fix: Resolve key length validation by hashing input keys

* refactor: Update keyshare import to use protocol decoding

* feat: Refactor enclave encryption to support full enclave export/import

* refactor: Simplify Enclave interface methods by removing role parameter

* refactor: remove unnecessary serialization from enclave interface

* refactor: rename models package in gateway context

* refactor: rename keystore vault constants

* refactor: remove context parameter from Resolver methods

* feat: add CurrentBlock context function and update related components

* refactor: rename resolver.go to resolvers.go

* feat: Add SQLite random() generation for session and profile initialization

* refactor: Update SQL queries to use SQLite-style parameter placeholders

* refactor: Replace '?' placeholders with '$n' PostgreSQL parameter syntax

* <no value>

* refactor: refactor gateway to use middleware for database interactions and improve modularity

* feat: implement gateway for Sonr highway

* refactor: Remove unused gateway context and refactor cookie/header handling

* refactor: improve server initialization and middleware handling

* feat: implement human verification for profile creation

* feat: implement session management middleware

* refactor: refactor common models and config to internal package

* refactor: move env config to internal/config

* refactor: move database-related code to  directory

* refactor: move IPFS client to common package and improve code structure

* refactor: move querier to common package and rename to chain_query

* refactor: move webworker model to internal/models

* feat: add initial view template for Sonr.ID

* docs(concepts): Add documentation for cosmos-proto

* docs: move IBC transfer documentation to tools section

* refactor: rename initpkl.go to pkl_init.go for better naming consistency

* docs(theme): update dark mode toggle icons

* refactor: update sqlite3 driver to ncruces/go-sqlite3

* feat: add Vault model and database interactions

* refactor: Improve SQLite schema with better constraints and indexes

* chore: update project dependencies

* fix: use grpc.WithInsecure() for gRPC connection

* config: set localhost as default Sonr gRPC URL

* refactor: improve gateway middleware and refactor server initialization

* refactor: Remove foreign key pragma from schema SQL

* refactor: Remove foreign key constraints from database schema

* refactor: Convert primary key columns from INTEGER to TEXT

* refactor: Remove unnecessary redirect in error handling

internal/config/env.go

@@ -0,0 +1,46 @@
+package config
+
+import (
+	"context"
+
+	"github.com/apple/pkl-go/pkl"
+	hwayconfig "github.com/onsonr/sonr/internal/config/hway"
+)
+
+// LoadFromBytes loads the environment from the given bytes
+func LoadHwayFromBytes(data []byte) (hwayconfig.Hway, error) {
+	text := string(data)
+	return LoadHwayFromString(text)
+}
+
+// LoadFromString loads the environment from the given string
+func LoadHwayFromString(text string) (hwayconfig.Hway, error) {
+	evaluator, err := pkl.NewEvaluator(context.Background(), pkl.PreconfiguredOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		cerr := evaluator.Close()
+		if err == nil {
+			err = cerr
+		}
+	}()
+	ret, err := hwayconfig.Load(context.Background(), evaluator, pkl.TextSource(text))
+	return ret, err
+}
+
+// LoadFromURL loads the environment from the given URL
+func LoadFromURL(url string) (hwayconfig.Hway, error) {
+	evaluator, err := pkl.NewEvaluator(context.Background(), pkl.PreconfiguredOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		cerr := evaluator.Close()
+		if err == nil {
+			err = cerr
+		}
+	}()
+	ret, err := hwayconfig.Load(context.Background(), evaluator, pkl.UriSource(url))
+	return ret, err
+}

internal/config/hway/Hway.pkl.go

@@ -0,0 +1,103 @@
+// Code generated from Pkl module `sonr.net.Hway`. DO NOT EDIT.
+package hway
+
+import (
+	"context"
+
+	"github.com/apple/pkl-go/pkl"
+)
+
+type Hway interface {
+	GetServePort() int
+
+	GetSqliteFile() string
+
+	GetChainId() string
+
+	GetIpfsGatewayUrl() string
+
+	GetSonrApiUrl() string
+
+	GetSonrGrpcUrl() string
+
+	GetSonrRpcUrl() string
+
+	GetPsqlDSN() string
+}
+
+var _ Hway = (*HwayImpl)(nil)
+
+type HwayImpl struct {
+	ServePort int `pkl:"servePort"`
+
+	SqliteFile string `pkl:"sqliteFile"`
+
+	ChainId string `pkl:"chainId"`
+
+	IpfsGatewayUrl string `pkl:"ipfsGatewayUrl"`
+
+	SonrApiUrl string `pkl:"sonrApiUrl"`
+
+	SonrGrpcUrl string `pkl:"sonrGrpcUrl"`
+
+	SonrRpcUrl string `pkl:"sonrRpcUrl"`
+
+	PsqlDSN string `pkl:"psqlDSN"`
+}
+
+func (rcv *HwayImpl) GetServePort() int {
+	return rcv.ServePort
+}
+
+func (rcv *HwayImpl) GetSqliteFile() string {
+	return rcv.SqliteFile
+}
+
+func (rcv *HwayImpl) GetChainId() string {
+	return rcv.ChainId
+}
+
+func (rcv *HwayImpl) GetIpfsGatewayUrl() string {
+	return rcv.IpfsGatewayUrl
+}
+
+func (rcv *HwayImpl) GetSonrApiUrl() string {
+	return rcv.SonrApiUrl
+}
+
+func (rcv *HwayImpl) GetSonrGrpcUrl() string {
+	return rcv.SonrGrpcUrl
+}
+
+func (rcv *HwayImpl) GetSonrRpcUrl() string {
+	return rcv.SonrRpcUrl
+}
+
+func (rcv *HwayImpl) GetPsqlDSN() string {
+	return rcv.PsqlDSN
+}
+
+// LoadFromPath loads the pkl module at the given path and evaluates it into a Hway
+func LoadFromPath(ctx context.Context, path string) (ret Hway, err error) {
+	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		cerr := evaluator.Close()
+		if err == nil {
+			err = cerr
+		}
+	}()
+	ret, err = Load(ctx, evaluator, pkl.FileSource(path))
+	return ret, err
+}
+
+// Load loads the pkl module at the given source and evaluates it with the given evaluator into a Hway
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Hway, error) {
+	var ret HwayImpl
+	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
+		return nil, err
+	}
+	return &ret, nil
+}

internal/config/hway/init.pkl.go

@@ -0,0 +1,8 @@
+// Code generated from Pkl module `sonr.net.Hway`. DO NOT EDIT.
+package hway
+
+import "github.com/apple/pkl-go/pkl"
+
+func init() {
+	pkl.RegisterMapping("sonr.net.Hway", HwayImpl{})
+}

internal/config/motr/Config.pkl.go

@@ -0,0 +1,18 @@
+// Code generated from Pkl module `sonr.net.Motr`. DO NOT EDIT.
+package motr
+
+type Config struct {
+	IpfsGatewayUrl string `pkl:"ipfsGatewayUrl" json:"ipfsGatewayUrl,omitempty"`
+
+	MotrToken string `pkl:"motrToken" json:"motrToken,omitempty"`
+
+	MotrAddress string `pkl:"motrAddress" json:"motrAddress,omitempty"`
+
+	SonrApiUrl string `pkl:"sonrApiUrl" json:"sonrApiUrl,omitempty"`
+
+	SonrRpcUrl string `pkl:"sonrRpcUrl" json:"sonrRpcUrl,omitempty"`
+
+	SonrChainId string `pkl:"sonrChainId" json:"sonrChainId,omitempty"`
+
+	VaultSchema *Schema `pkl:"vaultSchema" json:"vaultSchema,omitempty"`
+}

internal/config/motr/Environment.pkl.go

@@ -0,0 +1,14 @@
+// Code generated from Pkl module `sonr.net.Motr`. DO NOT EDIT.
+package motr
+
+type Environment struct {
+	IsDevelopment bool `pkl:"isDevelopment" json:"isDevelopment,omitempty"`
+
+	CacheVersion string `pkl:"cacheVersion" json:"cacheVersion,omitempty"`
+
+	HttpserverPath string `pkl:"httpserverPath" json:"httpserverPath,omitempty"`
+
+	WasmExecPath string `pkl:"wasmExecPath" json:"wasmExecPath,omitempty"`
+
+	WasmPath string `pkl:"wasmPath" json:"wasmPath,omitempty"`
+}

internal/config/motr/Motr.pkl.go

@@ -0,0 +1,36 @@
+// Code generated from Pkl module `sonr.net.Motr`. DO NOT EDIT.
+package motr
+
+import (
+	"context"
+
+	"github.com/apple/pkl-go/pkl"
+)
+
+type Motr struct {
+}
+
+// LoadFromPath loads the pkl module at the given path and evaluates it into a Motr
+func LoadFromPath(ctx context.Context, path string) (ret *Motr, err error) {
+	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		cerr := evaluator.Close()
+		if err == nil {
+			err = cerr
+		}
+	}()
+	ret, err = Load(ctx, evaluator, pkl.FileSource(path))
+	return ret, err
+}
+
+// Load loads the pkl module at the given source and evaluates it with the given evaluator into a Motr
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Motr, error) {
+	var ret Motr
+	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
+		return nil, err
+	}
+	return &ret, nil
+}

internal/config/motr/Schema.pkl.go

@@ -0,0 +1,22 @@
+// Code generated from Pkl module `sonr.net.Motr`. DO NOT EDIT.
+package motr
+
+type Schema struct {
+	Version int `pkl:"version"`
+
+	Account string `pkl:"account" json:"account,omitempty"`
+
+	Asset string `pkl:"asset" json:"asset,omitempty"`
+
+	Chain string `pkl:"chain" json:"chain,omitempty"`
+
+	Credential string `pkl:"credential" json:"credential,omitempty"`
+
+	Jwk string `pkl:"jwk" json:"jwk,omitempty"`
+
+	Grant string `pkl:"grant" json:"grant,omitempty"`
+
+	Keyshare string `pkl:"keyshare" json:"keyshare,omitempty"`
+
+	Profile string `pkl:"profile" json:"profile,omitempty"`
+}

internal/config/motr/init.pkl.go

@@ -0,0 +1,11 @@
+// Code generated from Pkl module `sonr.net.Motr`. DO NOT EDIT.
+package motr
+
+import "github.com/apple/pkl-go/pkl"
+
+func init() {
+	pkl.RegisterMapping("sonr.net.Motr", Motr{})
+	pkl.RegisterMapping("sonr.net.Motr#Config", Config{})
+	pkl.RegisterMapping("sonr.net.Motr#Schema", Schema{})
+	pkl.RegisterMapping("sonr.net.Motr#Environment", Environment{})
+}

internal/context/cookies.go

@@ -0,0 +1,124 @@
+package context
+
+import (
+	"encoding/base64"
+	"net/http"
+	"time"
+
+	"github.com/labstack/echo/v4"
+)
+
+// CookieKey is a type alias for string.
+type CookieKey string
+
+const (
+	// SessionID is the key for the session ID cookie.
+	SessionID CookieKey = "session.id"
+
+	// SessionChallenge is the key for the session challenge cookie.
+	SessionChallenge CookieKey = "session.challenge"
+
+	// SessionRole is the key for the session role cookie.
+	SessionRole CookieKey = "session.role"
+
+	// SonrAddress is the key for the Sonr address cookie.
+	SonrAddress CookieKey = "sonr.address"
+
+	// SonrDID is the key for the Sonr DID cookie.
+	SonrDID CookieKey = "sonr.did"
+
+	// UserAvatar is the key for the User Avatar cookie.
+	UserAvatar CookieKey = "user.avatar"
+
+	// UserHandle is the key for the User Handle cookie.
+	UserHandle CookieKey = "user.handle"
+
+	// UserName is the key for the User Name cookie.
+	UserName CookieKey = "user.full_name"
+
+	// VaultAddress is the key for the Vault address cookie.
+	VaultAddress CookieKey = "vault.address"
+
+	// VaultCID is the key for the Vault CID cookie.
+	VaultCID CookieKey = "vault.cid"
+
+	// VaultSchema is the key for the Vault schema cookie.
+	VaultSchema CookieKey = "vault.schema"
+)
+
+// String returns the string representation of the CookieKey.
+func (c CookieKey) String() string {
+	return string(c)
+}
+
+// ╭───────────────────────────────────────────────────────────╮
+// │                      Utility Methods                      │
+// ╰───────────────────────────────────────────────────────────╯
+
+func CookieExists(c echo.Context, key CookieKey) bool {
+	ck, err := c.Cookie(key.String())
+	if err != nil {
+		return false
+	}
+	return ck != nil
+}
+
+func ReadCookie(c echo.Context, key CookieKey) (string, error) {
+	cookie, err := c.Cookie(key.String())
+	if err != nil {
+		// Cookie not found or other error
+		return "", err
+	}
+	if cookie == nil || cookie.Value == "" {
+		// Cookie is empty
+		return "", http.ErrNoCookie
+	}
+	return cookie.Value, nil
+}
+
+func ReadCookieBytes(c echo.Context, key CookieKey) ([]byte, error) {
+	cookie, err := c.Cookie(key.String())
+	if err != nil {
+		// Cookie not found or other error
+		return nil, err
+	}
+	if cookie == nil || cookie.Value == "" {
+		// Cookie is empty
+		return nil, http.ErrNoCookie
+	}
+	return base64.RawURLEncoding.DecodeString(cookie.Value)
+}
+
+func ReadCookieUnsafe(c echo.Context, key CookieKey) string {
+	ck, err := c.Cookie(key.String())
+	if err != nil {
+		return ""
+	}
+	return ck.Value
+}
+
+func WriteCookie(c echo.Context, key CookieKey, value string) error {
+	cookie := &http.Cookie{
+		Name:     key.String(),
+		Value:    value,
+		Expires:  time.Now().Add(24 * time.Hour),
+		HttpOnly: true,
+		Path:     "/",
+		// Add Secure and SameSite attributes as needed
+	}
+	c.SetCookie(cookie)
+	return nil
+}
+
+func WriteCookieBytes(c echo.Context, key CookieKey, value []byte) error {
+	cookie := &http.Cookie{
+		Name:     key.String(),
+		Value:    base64.RawURLEncoding.EncodeToString(value),
+		Expires:  time.Now().Add(24 * time.Hour),
+		HttpOnly: true,
+		Path:     "/",
+		// Add Secure and SameSite attributes as needed
+	}
+	c.SetCookie(cookie)
+	return nil
+}

internal/context/headers.go

@@ -0,0 +1,52 @@
+package context
+
+import "github.com/labstack/echo/v4"
+
+type HeaderKey string
+
+const (
+	Authorization HeaderKey = "Authorization"
+
+	// User Agent
+	Architecture    HeaderKey = "Sec-CH-UA-Arch"
+	Bitness         HeaderKey = "Sec-CH-UA-Bitness"
+	FullVersionList HeaderKey = "Sec-CH-UA-Full-Version-List"
+	Mobile          HeaderKey = "Sec-CH-UA-Mobile"
+	Model           HeaderKey = "Sec-CH-UA-Model"
+	Platform        HeaderKey = "Sec-CH-UA-Platform"
+	PlatformVersion HeaderKey = "Sec-CH-UA-Platform-Version"
+	UserAgent       HeaderKey = "Sec-CH-UA"
+
+	// Sonr Injected
+	SonrAPIURL  HeaderKey = "X-Sonr-API"
+	SonrgRPCURL HeaderKey = "X-Sonr-GRPC"
+	SonrRPCURL  HeaderKey = "X-Sonr-RPC"
+	SonrWSURL   HeaderKey = "X-Sonr-WS"
+)
+
+func (h HeaderKey) String() string {
+	return string(h)
+}
+
+// ╭───────────────────────────────────────────────────────────╮
+// │                      Utility Methods                      │
+// ╰───────────────────────────────────────────────────────────╯
+
+func HeaderEquals(c echo.Context, key HeaderKey, value string) bool {
+	return c.Response().Header().Get(key.String()) == value
+}
+
+// HeaderExists returns true if the request has the header Key.
+func HeaderExists(c echo.Context, key HeaderKey) bool {
+	return c.Response().Header().Get(key.String()) != ""
+}
+
+// HeaderRead returns the header value for the Key.
+func HeaderRead(c echo.Context, key HeaderKey) string {
+	return c.Response().Header().Get(key.String())
+}
+
+// HeaderWrite sets the header value for the Key.
+func HeaderWrite(c echo.Context, key HeaderKey, value string) {
+	c.Response().Header().Set(key.String(), value)
+}

internal/database/conn.go

@@ -0,0 +1,25 @@
+package database
+
+import (
+	"context"
+	"database/sql"
+
+	_ "github.com/ncruces/go-sqlite3/driver"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	config "github.com/onsonr/sonr/internal/config/hway"
+	"github.com/onsonr/sonr/internal/database/sink"
+)
+
+// NewDB initializes and returns a configured database connection
+func NewDB(env config.Hway) (*sql.DB, error) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		return nil, err
+	}
+
+	// create tables
+	if _, err := db.ExecContext(context.Background(), sink.SchemaSQL); err != nil {
+		return nil, err
+	}
+	return db, nil
+}

internal/database/repository/db.go

@@ -0,0 +1,31 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.27.0
+
+package repository
+
+import (
+	"context"
+	"database/sql"
+)
+
+type DBTX interface {
+	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
+	PrepareContext(context.Context, string) (*sql.Stmt, error)
+	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
+	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
+}
+
+func New(db DBTX) *Queries {
+	return &Queries{db: db}
+}
+
+type Queries struct {
+	db DBTX
+}
+
+func (q *Queries) WithTx(tx *sql.Tx) *Queries {
+	return &Queries{
+		db: tx,
+	}
+}

internal/database/repository/models.go

@@ -0,0 +1,99 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.27.0
+
+package repository
+
+import (
+	"database/sql"
+	"time"
+)
+
+type Account struct {
+	ID            string
+	CreatedAt     time.Time
+	UpdatedAt     time.Time
+	DeletedAt     sql.NullTime
+	Number        int64
+	Sequence      int64
+	Address       string
+	PublicKey     string
+	ChainID       string
+	Controller    string
+	IsSubsidiary  bool
+	IsValidator   bool
+	IsDelegator   bool
+	IsAccountable bool
+}
+
+type Asset struct {
+	ID          string
+	CreatedAt   time.Time
+	UpdatedAt   time.Time
+	DeletedAt   sql.NullTime
+	Name        string
+	Symbol      string
+	Decimals    int64
+	ChainID     string
+	Channel     string
+	AssetType   string
+	CoingeckoID sql.NullString
+}
+
+type Credential struct {
+	ID                      int64
+	CreatedAt               time.Time
+	UpdatedAt               time.Time
+	DeletedAt               sql.NullTime
+	Handle                  string
+	CredentialID            string
+	AuthenticatorAttachment string
+	Origin                  string
+	Type                    string
+	Transports              string
+}
+
+type Profile struct {
+	ID        int64
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	DeletedAt sql.NullTime
+	Address   string
+	Handle    string
+	Origin    string
+	Name      string
+}
+
+type Session struct {
+	ID             string
+	CreatedAt      time.Time
+	UpdatedAt      time.Time
+	DeletedAt      sql.NullTime
+	BrowserName    string
+	BrowserVersion string
+	ClientIpaddr   string
+	Platform       string
+	IsDesktop      bool
+	IsMobile       bool
+	IsTablet       bool
+	IsTv           bool
+	IsBot          bool
+	Challenge      string
+	IsHumanFirst   bool
+	IsHumanLast    bool
+	ProfileID      int64
+}
+
+type Vault struct {
+	ID          int64
+	CreatedAt   time.Time
+	UpdatedAt   time.Time
+	DeletedAt   sql.NullTime
+	Handle      string
+	Origin      string
+	Address     string
+	Cid         string
+	Config      string
+	SessionID   string
+	RedirectUri string
+}

internal/database/repository/query.sql.go

@@ -0,0 +1,581 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.27.0
+// source: query.sql
+
+package repository
+
+import (
+	"context"
+)
+
+const checkHandleExists = `-- name: CheckHandleExists :one
+SELECT COUNT(*) > 0 as handle_exists FROM profiles 
+WHERE handle = ? 
+AND deleted_at IS NULL
+`
+
+func (q *Queries) CheckHandleExists(ctx context.Context, handle string) (bool, error) {
+	row := q.db.QueryRowContext(ctx, checkHandleExists, handle)
+	var handle_exists bool
+	err := row.Scan(&handle_exists)
+	return handle_exists, err
+}
+
+const createSession = `-- name: CreateSession :one
+INSERT INTO sessions (
+    id,
+    browser_name,
+    browser_version,
+    client_ipaddr,
+    platform,
+    is_desktop,
+    is_mobile,
+    is_tablet,
+    is_tv,
+    is_bot,
+    challenge,
+    is_human_first,
+    is_human_last,
+    profile_id
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )
+RETURNING id, created_at, updated_at, deleted_at, browser_name, browser_version, client_ipaddr, platform, is_desktop, is_mobile, is_tablet, is_tv, is_bot, challenge, is_human_first, is_human_last, profile_id
+`
+
+type CreateSessionParams struct {
+	ID             string
+	BrowserName    string
+	BrowserVersion string
+	ClientIpaddr   string
+	Platform       string
+	IsDesktop      bool
+	IsMobile       bool
+	IsTablet       bool
+	IsTv           bool
+	IsBot          bool
+	Challenge      string
+	IsHumanFirst   bool
+	IsHumanLast    bool
+	ProfileID      int64
+}
+
+func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) (Session, error) {
+	row := q.db.QueryRowContext(ctx, createSession,
+		arg.ID,
+		arg.BrowserName,
+		arg.BrowserVersion,
+		arg.ClientIpaddr,
+		arg.Platform,
+		arg.IsDesktop,
+		arg.IsMobile,
+		arg.IsTablet,
+		arg.IsTv,
+		arg.IsBot,
+		arg.Challenge,
+		arg.IsHumanFirst,
+		arg.IsHumanLast,
+		arg.ProfileID,
+	)
+	var i Session
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.BrowserName,
+		&i.BrowserVersion,
+		&i.ClientIpaddr,
+		&i.Platform,
+		&i.IsDesktop,
+		&i.IsMobile,
+		&i.IsTablet,
+		&i.IsTv,
+		&i.IsBot,
+		&i.Challenge,
+		&i.IsHumanFirst,
+		&i.IsHumanLast,
+		&i.ProfileID,
+	)
+	return i, err
+}
+
+const getChallengeBySessionID = `-- name: GetChallengeBySessionID :one
+SELECT challenge FROM sessions
+WHERE id = ? AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetChallengeBySessionID(ctx context.Context, id string) (string, error) {
+	row := q.db.QueryRowContext(ctx, getChallengeBySessionID, id)
+	var challenge string
+	err := row.Scan(&challenge)
+	return challenge, err
+}
+
+const getCredentialByID = `-- name: GetCredentialByID :one
+SELECT id, created_at, updated_at, deleted_at, handle, credential_id, authenticator_attachment, origin, type, transports FROM credentials
+WHERE credential_id = ?
+AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetCredentialByID(ctx context.Context, credentialID string) (Credential, error) {
+	row := q.db.QueryRowContext(ctx, getCredentialByID, credentialID)
+	var i Credential
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.Handle,
+		&i.CredentialID,
+		&i.AuthenticatorAttachment,
+		&i.Origin,
+		&i.Type,
+		&i.Transports,
+	)
+	return i, err
+}
+
+const getCredentialsByHandle = `-- name: GetCredentialsByHandle :many
+SELECT id, created_at, updated_at, deleted_at, handle, credential_id, authenticator_attachment, origin, type, transports FROM credentials
+WHERE handle = ?
+AND deleted_at IS NULL
+`
+
+func (q *Queries) GetCredentialsByHandle(ctx context.Context, handle string) ([]Credential, error) {
+	rows, err := q.db.QueryContext(ctx, getCredentialsByHandle, handle)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []Credential
+	for rows.Next() {
+		var i Credential
+		if err := rows.Scan(
+			&i.ID,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+			&i.DeletedAt,
+			&i.Handle,
+			&i.CredentialID,
+			&i.AuthenticatorAttachment,
+			&i.Origin,
+			&i.Type,
+			&i.Transports,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const getHumanVerificationNumbers = `-- name: GetHumanVerificationNumbers :one
+SELECT is_human_first, is_human_last FROM sessions
+WHERE id = ? AND deleted_at IS NULL
+LIMIT 1
+`
+
+type GetHumanVerificationNumbersRow struct {
+	IsHumanFirst bool
+	IsHumanLast  bool
+}
+
+func (q *Queries) GetHumanVerificationNumbers(ctx context.Context, id string) (GetHumanVerificationNumbersRow, error) {
+	row := q.db.QueryRowContext(ctx, getHumanVerificationNumbers, id)
+	var i GetHumanVerificationNumbersRow
+	err := row.Scan(&i.IsHumanFirst, &i.IsHumanLast)
+	return i, err
+}
+
+const getProfileByAddress = `-- name: GetProfileByAddress :one
+SELECT id, created_at, updated_at, deleted_at, address, handle, origin, name FROM profiles
+WHERE address = ? AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetProfileByAddress(ctx context.Context, address string) (Profile, error) {
+	row := q.db.QueryRowContext(ctx, getProfileByAddress, address)
+	var i Profile
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.Address,
+		&i.Handle,
+		&i.Origin,
+		&i.Name,
+	)
+	return i, err
+}
+
+const getProfileByHandle = `-- name: GetProfileByHandle :one
+SELECT id, created_at, updated_at, deleted_at, address, handle, origin, name FROM profiles
+WHERE handle = ? 
+AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetProfileByHandle(ctx context.Context, handle string) (Profile, error) {
+	row := q.db.QueryRowContext(ctx, getProfileByHandle, handle)
+	var i Profile
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.Address,
+		&i.Handle,
+		&i.Origin,
+		&i.Name,
+	)
+	return i, err
+}
+
+const getProfileByID = `-- name: GetProfileByID :one
+SELECT id, created_at, updated_at, deleted_at, address, handle, origin, name FROM profiles
+WHERE id = ? AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetProfileByID(ctx context.Context, id int64) (Profile, error) {
+	row := q.db.QueryRowContext(ctx, getProfileByID, id)
+	var i Profile
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.Address,
+		&i.Handle,
+		&i.Origin,
+		&i.Name,
+	)
+	return i, err
+}
+
+const getSessionByClientIP = `-- name: GetSessionByClientIP :one
+SELECT id, created_at, updated_at, deleted_at, browser_name, browser_version, client_ipaddr, platform, is_desktop, is_mobile, is_tablet, is_tv, is_bot, challenge, is_human_first, is_human_last, profile_id FROM sessions
+WHERE client_ipaddr = ? AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetSessionByClientIP(ctx context.Context, clientIpaddr string) (Session, error) {
+	row := q.db.QueryRowContext(ctx, getSessionByClientIP, clientIpaddr)
+	var i Session
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.BrowserName,
+		&i.BrowserVersion,
+		&i.ClientIpaddr,
+		&i.Platform,
+		&i.IsDesktop,
+		&i.IsMobile,
+		&i.IsTablet,
+		&i.IsTv,
+		&i.IsBot,
+		&i.Challenge,
+		&i.IsHumanFirst,
+		&i.IsHumanLast,
+		&i.ProfileID,
+	)
+	return i, err
+}
+
+const getSessionByID = `-- name: GetSessionByID :one
+SELECT id, created_at, updated_at, deleted_at, browser_name, browser_version, client_ipaddr, platform, is_desktop, is_mobile, is_tablet, is_tv, is_bot, challenge, is_human_first, is_human_last, profile_id FROM sessions
+WHERE id = ? AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetSessionByID(ctx context.Context, id string) (Session, error) {
+	row := q.db.QueryRowContext(ctx, getSessionByID, id)
+	var i Session
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.BrowserName,
+		&i.BrowserVersion,
+		&i.ClientIpaddr,
+		&i.Platform,
+		&i.IsDesktop,
+		&i.IsMobile,
+		&i.IsTablet,
+		&i.IsTv,
+		&i.IsBot,
+		&i.Challenge,
+		&i.IsHumanFirst,
+		&i.IsHumanLast,
+		&i.ProfileID,
+	)
+	return i, err
+}
+
+const getVaultConfigByCID = `-- name: GetVaultConfigByCID :one
+SELECT id, created_at, updated_at, deleted_at, handle, origin, address, cid, config, session_id, redirect_uri FROM vaults
+WHERE cid = ? 
+AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetVaultConfigByCID(ctx context.Context, cid string) (Vault, error) {
+	row := q.db.QueryRowContext(ctx, getVaultConfigByCID, cid)
+	var i Vault
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.Handle,
+		&i.Origin,
+		&i.Address,
+		&i.Cid,
+		&i.Config,
+		&i.SessionID,
+		&i.RedirectUri,
+	)
+	return i, err
+}
+
+const getVaultRedirectURIBySessionID = `-- name: GetVaultRedirectURIBySessionID :one
+SELECT redirect_uri FROM vaults
+WHERE session_id = ? 
+AND deleted_at IS NULL
+LIMIT 1
+`
+
+func (q *Queries) GetVaultRedirectURIBySessionID(ctx context.Context, sessionID string) (string, error) {
+	row := q.db.QueryRowContext(ctx, getVaultRedirectURIBySessionID, sessionID)
+	var redirect_uri string
+	err := row.Scan(&redirect_uri)
+	return redirect_uri, err
+}
+
+const insertCredential = `-- name: InsertCredential :one
+INSERT INTO credentials (
+    handle,
+    credential_id,
+    origin,
+    type,
+    transports
+) VALUES (?, ?, ?, ?, ?)
+RETURNING id, created_at, updated_at, deleted_at, handle, credential_id, authenticator_attachment, origin, type, transports
+`
+
+type InsertCredentialParams struct {
+	Handle       string
+	CredentialID string
+	Origin       string
+	Type         string
+	Transports   string
+}
+
+func (q *Queries) InsertCredential(ctx context.Context, arg InsertCredentialParams) (Credential, error) {
+	row := q.db.QueryRowContext(ctx, insertCredential,
+		arg.Handle,
+		arg.CredentialID,
+		arg.Origin,
+		arg.Type,
+		arg.Transports,
+	)
+	var i Credential
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.Handle,
+		&i.CredentialID,
+		&i.AuthenticatorAttachment,
+		&i.Origin,
+		&i.Type,
+		&i.Transports,
+	)
+	return i, err
+}
+
+const insertProfile = `-- name: InsertProfile :one
+INSERT INTO profiles (
+    address,
+    handle,
+    origin,
+    name
+) VALUES (?, ?, ?, ?)
+RETURNING id, created_at, updated_at, deleted_at, address, handle, origin, name
+`
+
+type InsertProfileParams struct {
+	Address string
+	Handle  string
+	Origin  string
+	Name    string
+}
+
+func (q *Queries) InsertProfile(ctx context.Context, arg InsertProfileParams) (Profile, error) {
+	row := q.db.QueryRowContext(ctx, insertProfile,
+		arg.Address,
+		arg.Handle,
+		arg.Origin,
+		arg.Name,
+	)
+	var i Profile
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.Address,
+		&i.Handle,
+		&i.Origin,
+		&i.Name,
+	)
+	return i, err
+}
+
+const softDeleteCredential = `-- name: SoftDeleteCredential :exec
+UPDATE credentials
+SET deleted_at = CURRENT_TIMESTAMP
+WHERE credential_id = ?
+`
+
+func (q *Queries) SoftDeleteCredential(ctx context.Context, credentialID string) error {
+	_, err := q.db.ExecContext(ctx, softDeleteCredential, credentialID)
+	return err
+}
+
+const softDeleteProfile = `-- name: SoftDeleteProfile :exec
+UPDATE profiles
+SET deleted_at = CURRENT_TIMESTAMP
+WHERE address = ?
+`
+
+func (q *Queries) SoftDeleteProfile(ctx context.Context, address string) error {
+	_, err := q.db.ExecContext(ctx, softDeleteProfile, address)
+	return err
+}
+
+const updateProfile = `-- name: UpdateProfile :one
+UPDATE profiles
+SET 
+    name = ?,
+    handle = ?,
+    updated_at = CURRENT_TIMESTAMP
+WHERE address = ? 
+AND deleted_at IS NULL
+RETURNING id, created_at, updated_at, deleted_at, address, handle, origin, name
+`
+
+type UpdateProfileParams struct {
+	Name    string
+	Handle  string
+	Address string
+}
+
+func (q *Queries) UpdateProfile(ctx context.Context, arg UpdateProfileParams) (Profile, error) {
+	row := q.db.QueryRowContext(ctx, updateProfile, arg.Name, arg.Handle, arg.Address)
+	var i Profile
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.Address,
+		&i.Handle,
+		&i.Origin,
+		&i.Name,
+	)
+	return i, err
+}
+
+const updateSessionHumanVerification = `-- name: UpdateSessionHumanVerification :one
+UPDATE sessions
+SET 
+    is_human_first = ?,
+    is_human_last = ?,
+    updated_at = CURRENT_TIMESTAMP
+WHERE id = ?
+RETURNING id, created_at, updated_at, deleted_at, browser_name, browser_version, client_ipaddr, platform, is_desktop, is_mobile, is_tablet, is_tv, is_bot, challenge, is_human_first, is_human_last, profile_id
+`
+
+type UpdateSessionHumanVerificationParams struct {
+	IsHumanFirst bool
+	IsHumanLast  bool
+	ID           string
+}
+
+func (q *Queries) UpdateSessionHumanVerification(ctx context.Context, arg UpdateSessionHumanVerificationParams) (Session, error) {
+	row := q.db.QueryRowContext(ctx, updateSessionHumanVerification, arg.IsHumanFirst, arg.IsHumanLast, arg.ID)
+	var i Session
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.BrowserName,
+		&i.BrowserVersion,
+		&i.ClientIpaddr,
+		&i.Platform,
+		&i.IsDesktop,
+		&i.IsMobile,
+		&i.IsTablet,
+		&i.IsTv,
+		&i.IsBot,
+		&i.Challenge,
+		&i.IsHumanFirst,
+		&i.IsHumanLast,
+		&i.ProfileID,
+	)
+	return i, err
+}
+
+const updateSessionWithProfileID = `-- name: UpdateSessionWithProfileID :one
+UPDATE sessions
+SET 
+    profile_id = ?,
+    updated_at = CURRENT_TIMESTAMP
+WHERE id = ?
+RETURNING id, created_at, updated_at, deleted_at, browser_name, browser_version, client_ipaddr, platform, is_desktop, is_mobile, is_tablet, is_tv, is_bot, challenge, is_human_first, is_human_last, profile_id
+`
+
+type UpdateSessionWithProfileIDParams struct {
+	ProfileID int64
+	ID        string
+}
+
+func (q *Queries) UpdateSessionWithProfileID(ctx context.Context, arg UpdateSessionWithProfileIDParams) (Session, error) {
+	row := q.db.QueryRowContext(ctx, updateSessionWithProfileID, arg.ProfileID, arg.ID)
+	var i Session
+	err := row.Scan(
+		&i.ID,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+		&i.DeletedAt,
+		&i.BrowserName,
+		&i.BrowserVersion,
+		&i.ClientIpaddr,
+		&i.Platform,
+		&i.IsDesktop,
+		&i.IsMobile,
+		&i.IsTablet,
+		&i.IsTv,
+		&i.IsBot,
+		&i.Challenge,
+		&i.IsHumanFirst,
+		&i.IsHumanLast,
+		&i.ProfileID,
+	)
+	return i, err
+}

internal/database/session.go

@@ -0,0 +1,58 @@
+package database
+
+import (
+	ctx "github.com/onsonr/sonr/internal/context"
+
+	"github.com/go-webauthn/webauthn/protocol"
+	"github.com/labstack/echo/v4"
+	"github.com/medama-io/go-useragent"
+	"github.com/onsonr/sonr/internal/database/repository"
+	"github.com/segmentio/ksuid"
+)
+
+func BaseSessionCreateParams(e echo.Context) repository.CreateSessionParams {
+	// f := rand.Intn(5) + 1
+	// l := rand.Intn(4) + 1
+	challenge, _ := protocol.CreateChallenge()
+	id := getOrCreateSessionID(e)
+	ua := useragent.NewParser()
+	s := ua.Parse(e.Request().UserAgent())
+
+	return repository.CreateSessionParams{
+		ID:             id,
+		BrowserName:    s.GetBrowser(),
+		BrowserVersion: s.GetMajorVersion(),
+		ClientIpaddr:   e.RealIP(),
+		Platform:       s.GetOS(),
+		IsMobile:       s.IsMobile(),
+		IsTablet:       s.IsTablet(),
+		IsDesktop:      s.IsDesktop(),
+		IsBot:          s.IsBot(),
+		IsTv:           s.IsTV(),
+		// IsHumanFirst:   int64(f),
+		// IsHumanLast:    int64(l),
+		Challenge: challenge.String(),
+	}
+}
+
+func getOrCreateSessionID(c echo.Context) string {
+	if ok := ctx.CookieExists(c, ctx.SessionID); !ok {
+		sessionID := ksuid.New().String()
+		ctx.WriteCookie(c, ctx.SessionID, sessionID)
+		return sessionID
+	}
+
+	sessionID, err := ctx.ReadCookie(c, ctx.SessionID)
+	if err != nil {
+		sessionID = ksuid.New().String()
+		ctx.WriteCookie(c, ctx.SessionID, sessionID)
+	}
+	return sessionID
+}
+
+func boolToInt64(b bool) int64 {
+	if b {
+		return 1
+	}
+	return 0
+}

internal/database/sink/embed.go

@@ -0,0 +1,8 @@
+package sink
+
+import (
+	_ "embed"
+)
+
+//go:embed schema.sql
+var SchemaSQL string

internal/database/sink/query.sql

@@ -0,0 +1,138 @@
+-- name: InsertCredential :one
+INSERT INTO credentials (
+    handle,
+    credential_id,
+    origin,
+    type,
+    transports
+) VALUES (?, ?, ?, ?, ?)
+RETURNING *;
+
+-- name: InsertProfile :one
+INSERT INTO profiles (
+    address,
+    handle,
+    origin,
+    name
+) VALUES (?, ?, ?, ?)
+RETURNING *;
+
+-- name: GetProfileByID :one
+SELECT * FROM profiles
+WHERE id = ? AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: GetProfileByAddress :one
+SELECT * FROM profiles
+WHERE address = ? AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: GetChallengeBySessionID :one
+SELECT challenge FROM sessions
+WHERE id = ? AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: GetHumanVerificationNumbers :one
+SELECT is_human_first, is_human_last FROM sessions
+WHERE id = ? AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: GetSessionByID :one
+SELECT * FROM sessions
+WHERE id = ? AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: GetSessionByClientIP :one
+SELECT * FROM sessions
+WHERE client_ipaddr = ? AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: UpdateSessionHumanVerification :one
+UPDATE sessions
+SET 
+    is_human_first = ?,
+    is_human_last = ?,
+    updated_at = CURRENT_TIMESTAMP
+WHERE id = ?
+RETURNING *;
+
+-- name: UpdateSessionWithProfileID :one
+UPDATE sessions
+SET 
+    profile_id = ?,
+    updated_at = CURRENT_TIMESTAMP
+WHERE id = ?
+RETURNING *;
+
+-- name: CheckHandleExists :one
+SELECT COUNT(*) > 0 as handle_exists FROM profiles 
+WHERE handle = ? 
+AND deleted_at IS NULL;
+
+-- name: GetCredentialsByHandle :many
+SELECT * FROM credentials
+WHERE handle = ?
+AND deleted_at IS NULL;
+
+-- name: GetCredentialByID :one
+SELECT * FROM credentials
+WHERE credential_id = ?
+AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: SoftDeleteCredential :exec
+UPDATE credentials
+SET deleted_at = CURRENT_TIMESTAMP
+WHERE credential_id = ?;
+
+-- name: SoftDeleteProfile :exec
+UPDATE profiles
+SET deleted_at = CURRENT_TIMESTAMP
+WHERE address = ?;
+
+-- name: UpdateProfile :one
+UPDATE profiles
+SET 
+    name = ?,
+    handle = ?,
+    updated_at = CURRENT_TIMESTAMP
+WHERE address = ? 
+AND deleted_at IS NULL
+RETURNING *;
+
+-- name: GetProfileByHandle :one
+SELECT * FROM profiles
+WHERE handle = ? 
+AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: GetVaultConfigByCID :one
+SELECT * FROM vaults
+WHERE cid = ? 
+AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: GetVaultRedirectURIBySessionID :one
+SELECT redirect_uri FROM vaults
+WHERE session_id = ? 
+AND deleted_at IS NULL
+LIMIT 1;
+
+-- name: CreateSession :one
+INSERT INTO sessions (
+    id,
+    browser_name,
+    browser_version,
+    client_ipaddr,
+    platform,
+    is_desktop,
+    is_mobile,
+    is_tablet,
+    is_tv,
+    is_bot,
+    challenge,
+    is_human_first,
+    is_human_last,
+    profile_id
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )
+RETURNING *;

internal/database/sink/schema.sql

@@ -0,0 +1,121 @@
+-- Profiles represent user identities
+CREATE TABLE profiles (
+    id TEXT PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    address TEXT NOT NULL,
+    handle TEXT NOT NULL UNIQUE,
+    origin TEXT NOT NULL,
+    name TEXT NOT NULL,
+    UNIQUE(address, origin)
+);
+
+-- Accounts represent blockchain accounts
+CREATE TABLE accounts (
+    id TEXT PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    number INTEGER NOT NULL,
+    sequence INTEGER NOT NULL DEFAULT 0,
+    address TEXT NOT NULL UNIQUE,
+    public_key TEXT NOT NULL CHECK(json_valid(public_key)),
+    chain_id TEXT NOT NULL,
+    controller TEXT NOT NULL,
+    is_subsidiary BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_subsidiary IN (0,1)),
+    is_validator BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_validator IN (0,1)),
+    is_delegator BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_delegator IN (0,1)),
+    is_accountable BOOLEAN NOT NULL DEFAULT TRUE CHECK(is_accountable IN (0,1))
+);
+
+-- Assets represent tokens and coins
+CREATE TABLE assets (
+    id TEXT PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    name TEXT NOT NULL,
+    symbol TEXT NOT NULL,
+    decimals INTEGER NOT NULL CHECK(decimals >= 0),
+    chain_id TEXT NOT NULL,
+    channel TEXT NOT NULL,
+    asset_type TEXT NOT NULL,
+    coingecko_id TEXT,
+    UNIQUE(chain_id, symbol)
+);
+
+-- Credentials store WebAuthn credentials
+CREATE TABLE credentials (
+    id TEXT PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    handle TEXT NOT NULL,
+    credential_id TEXT NOT NULL UNIQUE,
+    authenticator_attachment TEXT NOT NULL,
+    origin TEXT NOT NULL,
+    type TEXT NOT NULL,
+    transports TEXT NOT NULL
+);
+
+-- Sessions track user authentication state
+CREATE TABLE sessions (
+    id TEXT PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    browser_name TEXT NOT NULL,
+    browser_version TEXT NOT NULL,
+    client_ipaddr TEXT NOT NULL,
+    platform TEXT NOT NULL,
+    is_desktop BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_desktop IN (0,1)),
+    is_mobile BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_mobile IN (0,1)), 
+    is_tablet BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_tablet IN (0,1)),
+    is_tv BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_tv IN (0,1)),
+    is_bot BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_bot IN (0,1)),
+    challenge TEXT NOT NULL,
+    is_human_first BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_human_first IN (0,1)),
+    is_human_last BOOLEAN NOT NULL DEFAULT FALSE CHECK(is_human_last IN (0,1)),
+    profile_id INTEGER NOT NULL
+);
+
+-- Vaults store encrypted data
+CREATE TABLE vaults (
+    id TEXT PRIMARY KEY,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP,
+    handle TEXT NOT NULL,
+    origin TEXT NOT NULL,
+    address TEXT NOT NULL,
+    cid TEXT NOT NULL UNIQUE,
+    config TEXT NOT NULL CHECK(json_valid(config)),
+    session_id TEXT NOT NULL,
+    redirect_uri TEXT NOT NULL
+);
+
+-- Indexes for common queries
+CREATE INDEX idx_profiles_handle ON profiles(handle);
+CREATE INDEX idx_profiles_address ON profiles(address);
+CREATE INDEX idx_profiles_deleted_at ON profiles(deleted_at);
+
+CREATE INDEX idx_accounts_address ON accounts(address);
+CREATE INDEX idx_accounts_chain_id ON accounts(chain_id);
+CREATE INDEX idx_accounts_deleted_at ON accounts(deleted_at);
+
+CREATE INDEX idx_assets_symbol ON assets(symbol);
+CREATE INDEX idx_assets_chain_id ON assets(chain_id);
+CREATE INDEX idx_assets_deleted_at ON assets(deleted_at);
+
+CREATE INDEX idx_credentials_handle ON credentials(handle);
+CREATE INDEX idx_credentials_origin ON credentials(origin);
+CREATE INDEX idx_credentials_deleted_at ON credentials(deleted_at);
+
+CREATE INDEX idx_sessions_profile_id ON sessions(profile_id);
+CREATE INDEX idx_sessions_client_ipaddr ON sessions(client_ipaddr);
+CREATE INDEX idx_sessions_deleted_at ON sessions(deleted_at);
+
+CREATE INDEX idx_vaults_handle ON vaults(handle);
+CREATE INDEX idx_vaults_session_id ON vaults(session_id);
+CREATE INDEX idx_vaults_deleted_at ON vaults(deleted_at);

internal/database/sqlc.yaml

@@ -0,0 +1,9 @@
+version: "2"
+sql:
+  - engine: "sqlite"
+    queries: "./sink/query.sql"
+    schema: "./sink/schema.sql"
+    gen:
+      go:
+        package: "repository"
+        out: "repository"

internal/gateway/context/context.go

@@ -1,50 +0,0 @@
-package context
-
-import (
-	"github.com/onsonr/sonr/internal/gateway/models"
-	"github.com/onsonr/sonr/pkg/common"
-	"github.com/segmentio/ksuid"
-)
-
-// initSession initializes or loads an existing session
-func (s *HTTPContext) initSession() error {
-	sessionID := s.getOrCreateSessionID()
-
-	// Try to load existing session
-	var sess models.Session
-	result := s.db.Where("id = ?", sessionID).First(&sess)
-	if result.Error != nil {
-		// Create new session if not found
-		sess = models.Session{
-			ID:             sessionID,
-			BrowserName:    s.GetBrowser(),
-			BrowserVersion: s.GetMajorVersion(),
-			Platform:       s.GetOS(),
-			IsMobile:       s.IsMobile(),
-			IsTablet:       s.IsTablet(),
-			IsDesktop:      s.IsDesktop(),
-			IsBot:          s.IsBot(),
-			IsTV:           s.IsTV(),
-		}
-		if err := s.db.Create(&sess).Error; err != nil {
-			return err
-		}
-	}
-	s.sess = &sess
-	return nil
-}
-
-func (s *HTTPContext) getOrCreateSessionID() string {
-	if ok := common.CookieExists(s.Context, common.SessionID); !ok {
-		sessionID := ksuid.New().String()
-		common.WriteCookie(s.Context, common.SessionID, sessionID)
-		return sessionID
-	}
-
-	sessionID, err := common.ReadCookie(s.Context, common.SessionID)
-	if err != nil {
-		sessionID = ksuid.New().String()
-		common.WriteCookie(s.Context, common.SessionID, sessionID)
-	}
-	return sessionID
-}

internal/gateway/context/middleware.go

@@ -1,63 +0,0 @@
-package context
-
-import (
-	"net/http"
-
-	"github.com/labstack/echo/v4"
-	"github.com/medama-io/go-useragent"
-	"github.com/onsonr/sonr/internal/gateway/models"
-	"github.com/onsonr/sonr/internal/gateway/services"
-	config "github.com/onsonr/sonr/pkg/config/hway"
-	"gorm.io/gorm"
-)
-
-// Middleware creates a new session middleware
-func Middleware(db *gorm.DB, env config.Hway) echo.MiddlewareFunc {
-	ua := useragent.NewParser()
-	return func(next echo.HandlerFunc) echo.HandlerFunc {
-		return func(c echo.Context) error {
-			agent := ua.Parse(c.Request().UserAgent())
-			cc := NewHTTPContext(c, db, agent, env.GetSonrGrpcUrl())
-			if err := cc.initSession(); err != nil {
-				return err
-			}
-			return next(cc)
-		}
-	}
-}
-
-// HTTPContext is the context for HTTP endpoints.
-type HTTPContext struct {
-	echo.Context
-	*services.ResolverService
-	db   *gorm.DB
-	sess *models.Session
-	user *models.User
-	env  config.Hway
-	useragent.UserAgent
-}
-
-// Get returns the HTTPContext from the echo context
-func Get(c echo.Context) (*HTTPContext, error) {
-	ctx, ok := c.(*HTTPContext)
-	if !ok {
-		return nil, echo.NewHTTPError(http.StatusInternalServerError, "Session Context not found")
-	}
-	return ctx, nil
-}
-
-// NewHTTPContext creates a new session context
-func NewHTTPContext(c echo.Context, db *gorm.DB, a useragent.UserAgent, grpcAddr string) *HTTPContext {
-	rsv := services.NewResolverService(grpcAddr)
-	return &HTTPContext{
-		Context:         c,
-		db:              db,
-		ResolverService: rsv,
-		UserAgent:       a,
-	}
-}
-
-// Session returns the current session
-func (s *HTTPContext) Session() *models.Session {
-	return s.sess
-}

internal/gateway/context/store.go

@@ -1,58 +0,0 @@
-package context
-
-import (
-	"fmt"
-
-	"github.com/labstack/echo/v4"
-	"github.com/onsonr/sonr/internal/gateway/models"
-)
-
-func InsertCredential(c echo.Context, handle string, cred *models.CredentialDescriptor) error {
-	sess, err := Get(c)
-	if err != nil {
-		return err
-	}
-	return sess.db.Save(cred.ToDBModel(handle, c.Request().Host)).Error
-}
-
-func InsertProfile(c echo.Context) error {
-	sess, err := Get(c)
-	if err != nil {
-		return err
-	}
-	handle := c.FormValue("handle")
-	firstName := c.FormValue("first_name")
-	lastName := c.FormValue("last_name")
-	return sess.db.Save(&models.User{
-		Handle: handle,
-		Name:   fmt.Sprintf("%s %s", firstName, lastName),
-	}).Error
-}
-
-// ╭───────────────────────────────────────────────────────╮
-// │                  DB Getter Functions                  │
-// ╰───────────────────────────────────────────────────────╯
-
-// SessionID returns the session ID
-func SessionID(c echo.Context) (string, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return "", err
-	}
-	return sess.Session().ID, nil
-}
-
-// HandleExists checks if a handle already exists in any session
-func HandleExists(c echo.Context, handle string) (bool, error) {
-	sess, err := Get(c)
-	if err != nil {
-		return false, err
-	}
-
-	var count int64
-	if err := sess.db.Model(&models.User{}).Where("handle = ?", handle).Count(&count).Error; err != nil {
-		return false, err
-	}
-
-	return count > 0, nil
-}

internal/gateway/handlers/render_index.go

@@ -1,21 +0,0 @@
-package handlers
-
-import (
-	"github.com/labstack/echo/v4"
-	"github.com/onsonr/sonr/internal/gateway/context"
-	"github.com/onsonr/sonr/internal/gateway/views"
-	"github.com/onsonr/sonr/pkg/common/response"
-)
-
-func RenderIndex(c echo.Context) error {
-	return response.TemplEcho(c, views.InitialView(isUnavailableDevice(c)))
-}
-
-// isUnavailableDevice returns true if the device is unavailable
-func isUnavailableDevice(c echo.Context) bool {
-	s, err := context.Get(c)
-	if err != nil {
-		return true
-	}
-	return s.IsBot() || s.IsTV()
-}

internal/gateway/handlers/render_register.go

@@ -1,54 +0,0 @@
-package handlers
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/go-webauthn/webauthn/protocol"
-	"github.com/labstack/echo/v4"
-	"github.com/onsonr/sonr/crypto/mpc"
-	"github.com/onsonr/sonr/internal/gateway/models"
-	"github.com/onsonr/sonr/internal/gateway/views"
-	"github.com/onsonr/sonr/pkg/common/response"
-	"golang.org/x/exp/rand"
-)
-
-func RenderProfileCreate(c echo.Context) error {
-	d := models.CreateProfileData{
-		FirstNumber: rand.Intn(5) + 1,
-		LastNumber:  rand.Intn(4) + 1,
-	}
-	return response.TemplEcho(c, views.CreateProfileForm(d))
-}
-
-func RenderPasskeyCreate(c echo.Context) error {
-	challenge, _ := protocol.CreateChallenge()
-	handle := c.FormValue("handle")
-	firstName := c.FormValue("first_name")
-	lastName := c.FormValue("last_name")
-
-	ks, err := mpc.GenEnclave()
-	if err != nil {
-		return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
-	}
-	dat := models.CreatePasskeyData{
-		Address:       ks.Address(),
-		Handle:        handle,
-		Name:          fmt.Sprintf("%s %s", firstName, lastName),
-		Challenge:     challenge.String(),
-		CreationBlock: "00001",
-	}
-	return response.TemplEcho(c, views.CreatePasskeyForm(dat))
-}
-
-func RenderVaultLoading(c echo.Context) error {
-	credentialJSON := c.FormValue("credential")
-	if credentialJSON == "" {
-		return echo.NewHTTPError(http.StatusBadRequest, "missing credential data")
-	}
-	_, err := models.ExtractCredentialDescriptor(credentialJSON)
-	if err != nil {
-		return err
-	}
-	return response.TemplEcho(c, views.LoadingVaultView())
-}

internal/gateway/handlers/validate_credential.go

@@ -1,11 +0,0 @@
-package handlers
-
-import (
-	"github.com/labstack/echo/v4"
-)
-
-// ValidateCredentialSubmit finds the user credential and validates it against the
-// session challenge
-func ValidateCredentialSubmit(c echo.Context) error {
-	return nil
-}

internal/gateway/handlers/validate_profile.go

@@ -1,8 +0,0 @@
-package handlers
-
-import "github.com/labstack/echo/v4"
-
-// ValidateProfileHandle finds the chosen handle and verifies it is unique
-func ValidateProfileSubmit(c echo.Context) error {
-	return nil
-}

internal/gateway/models/db_orm.go

@@ -1,37 +0,0 @@
-package models
-
-import (
-	"gorm.io/gorm"
-)
-
-type Credential struct {
-	gorm.Model
-	Handle     string `json:"handle"`
-	ID         string `json:"id"`
-	Origin     string `json:"origin"`
-	Type       string `json:"type"`
-	Transports string `json:"transports"`
-}
-
-type Session struct {
-	gorm.Model
-	ID             string `json:"id" gorm:"primaryKey"`
-	BrowserName    string `json:"browserName"`
-	BrowserVersion string `json:"browserVersion"`
-	Platform       string `json:"platform"`
-	IsDesktop      bool   `json:"isDesktop"`
-	IsMobile       bool   `json:"isMobile"`
-	IsTablet       bool   `json:"isTablet"`
-	IsTV           bool   `json:"isTV"`
-	IsBot          bool   `json:"isBot"`
-	Challenge      string `json:"challenge"`
-}
-
-type User struct {
-	gorm.Model
-	Address string `json:"address"`
-	Handle  string `json:"handle"`
-	Origin  string `json:"origin"`
-	Name    string `json:"name"`
-	CID     string `json:"cid"`
-}

internal/gateway/models/form_data.go

@@ -1,15 +0,0 @@
-package models
-
-type CreatePasskeyData struct {
-	Address       string
-	Handle        string
-	Name          string
-	Challenge     string
-	CreationBlock string
-}
-
-type CreateProfileData struct {
-	TurnstileSiteKey string
-	FirstNumber      int
-	LastNumber       int
-}

internal/gateway/models/resolver.go

@@ -1 +0,0 @@
-package models

internal/gateway/models/webauthn.go

@@ -1,64 +0,0 @@
-package models
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-// Define the credential structure matching our frontend data
-type CredentialDescriptor struct {
-	ID                      string            `json:"id"`
-	RawID                   string            `json:"rawId"`
-	Type                    string            `json:"type"`
-	AuthenticatorAttachment string            `json:"authenticatorAttachment"`
-	Transports              string            `json:"transports"`
-	ClientExtensionResults  map[string]string `json:"clientExtensionResults"`
-	Response                struct {
-		AttestationObject string `json:"attestationObject"`
-		ClientDataJSON    string `json:"clientDataJSON"`
-	} `json:"response"`
-}
-
-func (c *CredentialDescriptor) ToDBModel(handle, origin string) *Credential {
-	return &Credential{
-		Handle:     handle,
-		Origin:     origin,
-		ID:         c.ID,
-		Type:       c.Type,
-		Transports: c.Transports,
-	}
-}
-
-func ExtractCredentialDescriptor(jsonString string) (*CredentialDescriptor, error) {
-	cred := &CredentialDescriptor{}
-	// Unmarshal the credential JSON
-	if err := json.Unmarshal([]byte(jsonString), cred); err != nil {
-		return nil, err
-	}
-
-	// Validate required fields
-	if cred.ID == "" || cred.RawID == "" {
-		return nil, fmt.Errorf("missing credential ID")
-	}
-	if cred.Type != "public-key" {
-		return nil, fmt.Errorf("invalid credential type")
-	}
-	if cred.Response.AttestationObject == "" || cred.Response.ClientDataJSON == "" {
-		return nil, fmt.Errorf("missing attestation data")
-	}
-
-	// Log detailed credential information
-	fmt.Printf("Credential Details:\n"+
-		"ID: %s\n"+
-		"Raw ID: %s\n"+
-		"Type: %s\n"+
-		"Authenticator Attachment: %s\n"+
-		"Transports: %v\n"+
-		cred.ID,
-		cred.RawID,
-		cred.Type,
-		cred.AuthenticatorAttachment,
-		cred.Transports,
-	)
-	return cred, nil
-}

internal/gateway/routes.go

@@ -1,81 +0,0 @@
-// Package gateway provides the default routes for the Sonr hway.
-package gateway
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/labstack/echo/v4"
-	"github.com/onsonr/sonr/internal/gateway/context"
-	"github.com/onsonr/sonr/internal/gateway/handlers"
-	"github.com/onsonr/sonr/internal/gateway/models"
-	"github.com/onsonr/sonr/pkg/common/response"
-	config "github.com/onsonr/sonr/pkg/config/hway"
-	"gorm.io/driver/postgres"
-	"gorm.io/driver/sqlite"
-	"gorm.io/gorm"
-)
-
-func RegisterRoutes(e *echo.Echo, env config.Hway, db *gorm.DB) error {
-	// Custom error handler for gateway
-	e.HTTPErrorHandler = response.RedirectOnError("http://localhost:3000")
-
-	// Inject session middleware with database connection
-	e.Use(context.Middleware(db, env))
-
-	// Register View Handlers
-	e.GET("/", handlers.RenderIndex)
-	e.GET("/register", handlers.RenderProfileCreate)
-	e.POST("/register/passkey", handlers.RenderPasskeyCreate)
-	e.POST("/register/loading", handlers.RenderVaultLoading)
-
-	// Register Validation Handlers
-	e.PUT("/register/profile/submit", handlers.ValidateProfileSubmit)
-	e.PUT("/register/passkey/submit", handlers.ValidateCredentialSubmit)
-	return nil
-}
-
-// NewGormDB initializes and returns a configured database connection
-func NewDB(env config.Hway) (*gorm.DB, error) {
-	// Try PostgreSQL first if DSN is provided
-	if dsn := env.GetPsqlDSN(); dsn != "" && !strings.Contains(dsn, "password= ") {
-		db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
-		if err == nil {
-			// Test the connection
-			sqlDB, err := db.DB()
-			if err == nil {
-				if err = sqlDB.Ping(); err == nil {
-					// Successfully connected to PostgreSQL
-					db.AutoMigrate(&models.Credential{})
-					db.AutoMigrate(&models.Session{})
-					db.AutoMigrate(&models.User{})
-					return db, nil
-				}
-			}
-		}
-	}
-
-	// Fall back to SQLite
-	path := formatDBPath(env.GetSqliteFile())
-	db, err := gorm.Open(sqlite.Open(path), &gorm.Config{})
-	if err != nil {
-		return nil, err
-	}
-
-	// Migrate the schema
-	db.AutoMigrate(&models.Credential{})
-	db.AutoMigrate(&models.Session{})
-	db.AutoMigrate(&models.User{})
-	return db, nil
-}
-
-func formatDBPath(fileName string) string {
-	configDir := filepath.Join(os.Getenv("XDG_CONFIG_HOME"), "hway")
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
-		// If we can't create the directory, fall back to current directory
-		return configDir
-	}
-
-	return filepath.Join(configDir, fileName)
-}

internal/gateway/services/resolver_service.go

@@ -1,59 +0,0 @@
-package services
-
-import (
-	bankv1beta1 "cosmossdk.io/api/cosmos/bank/v1beta1"
-	didv1 "github.com/onsonr/sonr/api/did/v1"
-	dwnv1 "github.com/onsonr/sonr/api/dwn/v1"
-	svcv1 "github.com/onsonr/sonr/api/svc/v1"
-	"google.golang.org/grpc"
-)
-
-type ResolverService struct {
-	grpcAddr string
-}
-
-func NewResolverService(grpcAddr string) *ResolverService {
-	return &ResolverService{
-		grpcAddr: grpcAddr,
-	}
-}
-
-func (s *ResolverService) getClientConn() (*grpc.ClientConn, error) {
-	grpcConn, err := grpc.NewClient(s.grpcAddr, grpc.WithInsecure())
-	if err != nil {
-		return nil, err
-	}
-	return grpcConn, nil
-}
-
-func (s *ResolverService) BankQuery() (bankv1beta1.QueryClient, error) {
-	conn, err := s.getClientConn()
-	if err != nil {
-		return nil, err
-	}
-	return bankv1beta1.NewQueryClient(conn), nil
-}
-
-func (s *ResolverService) DIDQuery() (didv1.QueryClient, error) {
-	conn, err := s.getClientConn()
-	if err != nil {
-		return nil, err
-	}
-	return didv1.NewQueryClient(conn), nil
-}
-
-func (s *ResolverService) DWNQuery() (dwnv1.QueryClient, error) {
-	conn, err := s.getClientConn()
-	if err != nil {
-		return nil, err
-	}
-	return dwnv1.NewQueryClient(conn), nil
-}
-
-func (s *ResolverService) SVCQuery() (svcv1.QueryClient, error) {
-	conn, err := s.getClientConn()
-	if err != nil {
-		return nil, err
-	}
-	return svcv1.NewQueryClient(conn), nil
-}

internal/gateway/services/user_service.go

@@ -1,7 +0,0 @@
-package services
-
-import "gorm.io/gorm"
-
-type UserService struct {
-	db *gorm.DB
-}

internal/gateway/services/vault_service.go

@@ -1,18 +0,0 @@
-package services
-
-import (
-	"github.com/onsonr/sonr/pkg/ipfsapi"
-	"gorm.io/gorm"
-)
-
-type VaultService struct {
-	db         *gorm.DB
-	tokenStore ipfsapi.IPFSTokenStore
-}
-
-func NewVaultService(db *gorm.DB, ipc ipfsapi.Client) *VaultService {
-	return &VaultService{
-		db:         db,
-		tokenStore: ipfsapi.NewUCANStore(ipc),
-	}
-}

internal/gateway/views/initial_view.templ

@@ -1,39 +0,0 @@
-package views
-
-import (
-	"github.com/onsonr/sonr/internal/nebula/hero"
-	"github.com/onsonr/sonr/internal/nebula/layout"
-)
-
-templ InitialView(isUnavailable bool) {
-	if isUnavailable {
-		@layout.View("Sonr.ID") {
-			@layout.Container() {
-				@hero.TitleDesc("Sonr.ID", "The decentralized identity layer for the web.")
-				@hero.SocialButtonsRow()
-			}
-		}
-	}
-	@layout.View("Sonr.ID") {
-		@layout.Container() {
-			@hero.TitleDesc("Sonr.ID", "The decentralized identity layer for the web.")
-			@hero.StartButton()
-			@hero.SocialButtonsRow()
-		}
-	}
-}
-
-templ ReturningView() {
-	@layout.View("Login | Sonr.ID") {
-		@layout.Container() {
-			@hero.TitleDesc("Welcome Back!", "Continue with your existing Sonr.ID.")
-			<div class="pt-3 flex flex-col items-center justify-center h-full">
-				<sl-button hx-target="#container" hx-get="/register" type="button">
-					<sl-icon slot="prefix" library="sonr" name="sonr"></sl-icon>
-					Log back in
-					<sl-icon slot="suffix" library="sonr" name="arrow-right"></sl-icon>
-				</sl-button>
-			</div>
-		}
-	}
-}

internal/gateway/views/initial_view_templ.go

@@ -1,216 +0,0 @@
-// Code generated by templ - DO NOT EDIT.
-
-// templ: version: v0.2.793
-package views
-
-//lint:file-ignore SA4006 This context is only used if a nested component is present.
-
-import "github.com/a-h/templ"
-import templruntime "github.com/a-h/templ/runtime"
-
-import (
-	"github.com/onsonr/sonr/internal/nebula/hero"
-	"github.com/onsonr/sonr/internal/nebula/layout"
-)
-
-func InitialView(isUnavailable bool) templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var1 == nil {
-			templ_7745c5c3_Var1 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		if isUnavailable {
-			templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-				if !templ_7745c5c3_IsBuffer {
-					defer func() {
-						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-						if templ_7745c5c3_Err == nil {
-							templ_7745c5c3_Err = templ_7745c5c3_BufErr
-						}
-					}()
-				}
-				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Var3 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-					templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-					templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-					if !templ_7745c5c3_IsBuffer {
-						defer func() {
-							templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-							if templ_7745c5c3_Err == nil {
-								templ_7745c5c3_Err = templ_7745c5c3_BufErr
-							}
-						}()
-					}
-					ctx = templ.InitializeContext(ctx)
-					templ_7745c5c3_Err = hero.TitleDesc("Sonr.ID", "The decentralized identity layer for the web.").Render(ctx, templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					templ_7745c5c3_Err = hero.SocialButtonsRow().Render(ctx, templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					return templ_7745c5c3_Err
-				})
-				templ_7745c5c3_Err = layout.Container().Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				return templ_7745c5c3_Err
-			})
-			templ_7745c5c3_Err = layout.View("Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-		}
-		templ_7745c5c3_Var4 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-			if !templ_7745c5c3_IsBuffer {
-				defer func() {
-					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err == nil {
-						templ_7745c5c3_Err = templ_7745c5c3_BufErr
-					}
-				}()
-			}
-			ctx = templ.InitializeContext(ctx)
-			templ_7745c5c3_Var5 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-				if !templ_7745c5c3_IsBuffer {
-					defer func() {
-						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-						if templ_7745c5c3_Err == nil {
-							templ_7745c5c3_Err = templ_7745c5c3_BufErr
-						}
-					}()
-				}
-				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Err = hero.TitleDesc("Sonr.ID", "The decentralized identity layer for the web.").Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = hero.StartButton().Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = hero.SocialButtonsRow().Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				return templ_7745c5c3_Err
-			})
-			templ_7745c5c3_Err = layout.Container().Render(templ.WithChildren(ctx, templ_7745c5c3_Var5), templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			return templ_7745c5c3_Err
-		})
-		templ_7745c5c3_Err = layout.View("Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var4), templ_7745c5c3_Buffer)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
-
-func ReturningView() templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var6 == nil {
-			templ_7745c5c3_Var6 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var7 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-			if !templ_7745c5c3_IsBuffer {
-				defer func() {
-					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err == nil {
-						templ_7745c5c3_Err = templ_7745c5c3_BufErr
-					}
-				}()
-			}
-			ctx = templ.InitializeContext(ctx)
-			templ_7745c5c3_Var8 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-				if !templ_7745c5c3_IsBuffer {
-					defer func() {
-						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-						if templ_7745c5c3_Err == nil {
-							templ_7745c5c3_Err = templ_7745c5c3_BufErr
-						}
-					}()
-				}
-				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Err = hero.TitleDesc("Welcome Back!", "Continue with your existing Sonr.ID.").Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" <div class=\"pt-3 flex flex-col items-center justify-center h-full\"><sl-button hx-target=\"#container\" hx-get=\"/register\" type=\"button\"><sl-icon slot=\"prefix\" library=\"sonr\" name=\"sonr\"></sl-icon> Log back in <sl-icon slot=\"suffix\" library=\"sonr\" name=\"arrow-right\"></sl-icon></sl-button></div>")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				return templ_7745c5c3_Err
-			})
-			templ_7745c5c3_Err = layout.Container().Render(templ.WithChildren(ctx, templ_7745c5c3_Var8), templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			return templ_7745c5c3_Err
-		})
-		templ_7745c5c3_Err = layout.View("Login | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var7), templ_7745c5c3_Buffer)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
-
-var _ = templruntime.GeneratedTemplate

internal/gateway/views/register_view.templ

@@ -1,69 +0,0 @@
-package views
-
-import (
-	"github.com/onsonr/sonr/internal/gateway/models"
-	"github.com/onsonr/sonr/internal/nebula/card"
-	"github.com/onsonr/sonr/internal/nebula/form"
-	"github.com/onsonr/sonr/internal/nebula/hero"
-	"github.com/onsonr/sonr/internal/nebula/input"
-	"github.com/onsonr/sonr/internal/nebula/layout"
-)
-
-templ CreateProfileForm(data models.CreateProfileData) {
-	@layout.View("New Profile | Sonr.ID") {
-		@layout.Container() {
-			@hero.TitleDesc("Basic Info", "Tell us a little about yourself.")
-			@formCreateProfile(data)
-		}
-	}
-}
-
-templ CreatePasskeyForm(data models.CreatePasskeyData) {
-	@layout.View("Register | Sonr.ID") {
-		@layout.Container() {
-			@hero.TitleDesc("Link a PassKey", "This will be used to login to your vault.")
-			@formCreatePasskey(data)
-		}
-	}
-}
-
-templ LoadingVaultView() {
-	@layout.View("Loading... | Sonr.ID") {
-		@layout.Container() {
-			@hero.TitleDesc("Loading Vault", "This will be used to login to your vault.")
-		}
-	}
-}
-
-templ formCreatePasskey(data models.CreatePasskeyData) {
-	@form.Root("/register/finish", "POST", "passkey-form") {
-		<input type="hidden" name="credential" id="credential-data" required/>
-		@form.Body() {
-			@form.Header() {
-				@card.SonrProfile(data.Address, data.Name, data.Handle, data.CreationBlock)
-			}
-			@input.CoinSelect()
-			@form.Footer() {
-				@input.Passkey(data.Address, data.Handle, data.Challenge)
-				@form.CancelButton()
-			}
-		}
-	}
-}
-
-templ formCreateProfile(data models.CreateProfileData) {
-	@form.Root("/register/passkey", "POST", "create-profile") {
-		@form.Body() {
-			@form.Header() {
-				<sl-progress-bar value="50"></sl-progress-bar>
-			}
-			@input.Name()
-			@input.Handle()
-			@input.HumanSlider(data.FirstNumber, data.LastNumber)
-			@form.Footer() {
-				@form.CancelButton()
-				@form.SubmitButton("Next")
-			}
-		}
-	}
-}

internal/gateway/views/register_view_templ.go

@@ -1,501 +0,0 @@
-// Code generated by templ - DO NOT EDIT.
-
-// templ: version: v0.2.793
-package views
-
-//lint:file-ignore SA4006 This context is only used if a nested component is present.
-
-import "github.com/a-h/templ"
-import templruntime "github.com/a-h/templ/runtime"
-
-import (
-	"github.com/onsonr/sonr/internal/gateway/models"
-	"github.com/onsonr/sonr/internal/nebula/card"
-	"github.com/onsonr/sonr/internal/nebula/form"
-	"github.com/onsonr/sonr/internal/nebula/hero"
-	"github.com/onsonr/sonr/internal/nebula/input"
-	"github.com/onsonr/sonr/internal/nebula/layout"
-)
-
-func CreateProfileForm(data models.CreateProfileData) templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var1 == nil {
-			templ_7745c5c3_Var1 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-			if !templ_7745c5c3_IsBuffer {
-				defer func() {
-					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err == nil {
-						templ_7745c5c3_Err = templ_7745c5c3_BufErr
-					}
-				}()
-			}
-			ctx = templ.InitializeContext(ctx)
-			templ_7745c5c3_Var3 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-				if !templ_7745c5c3_IsBuffer {
-					defer func() {
-						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-						if templ_7745c5c3_Err == nil {
-							templ_7745c5c3_Err = templ_7745c5c3_BufErr
-						}
-					}()
-				}
-				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Err = hero.TitleDesc("Basic Info", "Tell us a little about yourself.").Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = formCreateProfile(data).Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				return templ_7745c5c3_Err
-			})
-			templ_7745c5c3_Err = layout.Container().Render(templ.WithChildren(ctx, templ_7745c5c3_Var3), templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			return templ_7745c5c3_Err
-		})
-		templ_7745c5c3_Err = layout.View("New Profile | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
-
-func CreatePasskeyForm(data models.CreatePasskeyData) templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var4 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var4 == nil {
-			templ_7745c5c3_Var4 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var5 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-			if !templ_7745c5c3_IsBuffer {
-				defer func() {
-					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err == nil {
-						templ_7745c5c3_Err = templ_7745c5c3_BufErr
-					}
-				}()
-			}
-			ctx = templ.InitializeContext(ctx)
-			templ_7745c5c3_Var6 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-				if !templ_7745c5c3_IsBuffer {
-					defer func() {
-						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-						if templ_7745c5c3_Err == nil {
-							templ_7745c5c3_Err = templ_7745c5c3_BufErr
-						}
-					}()
-				}
-				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Err = hero.TitleDesc("Link a PassKey", "This will be used to login to your vault.").Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = formCreatePasskey(data).Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				return templ_7745c5c3_Err
-			})
-			templ_7745c5c3_Err = layout.Container().Render(templ.WithChildren(ctx, templ_7745c5c3_Var6), templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			return templ_7745c5c3_Err
-		})
-		templ_7745c5c3_Err = layout.View("Register | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var5), templ_7745c5c3_Buffer)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
-
-func LoadingVaultView() templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var7 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var7 == nil {
-			templ_7745c5c3_Var7 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var8 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-			if !templ_7745c5c3_IsBuffer {
-				defer func() {
-					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err == nil {
-						templ_7745c5c3_Err = templ_7745c5c3_BufErr
-					}
-				}()
-			}
-			ctx = templ.InitializeContext(ctx)
-			templ_7745c5c3_Var9 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-				if !templ_7745c5c3_IsBuffer {
-					defer func() {
-						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-						if templ_7745c5c3_Err == nil {
-							templ_7745c5c3_Err = templ_7745c5c3_BufErr
-						}
-					}()
-				}
-				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Err = hero.TitleDesc("Loading Vault", "This will be used to login to your vault.").Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				return templ_7745c5c3_Err
-			})
-			templ_7745c5c3_Err = layout.Container().Render(templ.WithChildren(ctx, templ_7745c5c3_Var9), templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			return templ_7745c5c3_Err
-		})
-		templ_7745c5c3_Err = layout.View("Loading... | Sonr.ID").Render(templ.WithChildren(ctx, templ_7745c5c3_Var8), templ_7745c5c3_Buffer)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
-
-func formCreatePasskey(data models.CreatePasskeyData) templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var10 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var10 == nil {
-			templ_7745c5c3_Var10 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var11 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-			if !templ_7745c5c3_IsBuffer {
-				defer func() {
-					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err == nil {
-						templ_7745c5c3_Err = templ_7745c5c3_BufErr
-					}
-				}()
-			}
-			ctx = templ.InitializeContext(ctx)
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<input type=\"hidden\" name=\"credential\" id=\"credential-data\" required>")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Var12 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-				if !templ_7745c5c3_IsBuffer {
-					defer func() {
-						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-						if templ_7745c5c3_Err == nil {
-							templ_7745c5c3_Err = templ_7745c5c3_BufErr
-						}
-					}()
-				}
-				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Var13 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-					templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-					templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-					if !templ_7745c5c3_IsBuffer {
-						defer func() {
-							templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-							if templ_7745c5c3_Err == nil {
-								templ_7745c5c3_Err = templ_7745c5c3_BufErr
-							}
-						}()
-					}
-					ctx = templ.InitializeContext(ctx)
-					templ_7745c5c3_Err = card.SonrProfile(data.Address, data.Name, data.Handle, data.CreationBlock).Render(ctx, templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					return templ_7745c5c3_Err
-				})
-				templ_7745c5c3_Err = form.Header().Render(templ.WithChildren(ctx, templ_7745c5c3_Var13), templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = input.CoinSelect().Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Var14 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-					templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-					templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-					if !templ_7745c5c3_IsBuffer {
-						defer func() {
-							templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-							if templ_7745c5c3_Err == nil {
-								templ_7745c5c3_Err = templ_7745c5c3_BufErr
-							}
-						}()
-					}
-					ctx = templ.InitializeContext(ctx)
-					templ_7745c5c3_Err = input.Passkey(data.Address, data.Handle, data.Challenge).Render(ctx, templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					templ_7745c5c3_Err = form.CancelButton().Render(ctx, templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					return templ_7745c5c3_Err
-				})
-				templ_7745c5c3_Err = form.Footer().Render(templ.WithChildren(ctx, templ_7745c5c3_Var14), templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				return templ_7745c5c3_Err
-			})
-			templ_7745c5c3_Err = form.Body().Render(templ.WithChildren(ctx, templ_7745c5c3_Var12), templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			return templ_7745c5c3_Err
-		})
-		templ_7745c5c3_Err = form.Root("/register/finish", "POST", "passkey-form").Render(templ.WithChildren(ctx, templ_7745c5c3_Var11), templ_7745c5c3_Buffer)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
-
-func formCreateProfile(data models.CreateProfileData) templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var15 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var15 == nil {
-			templ_7745c5c3_Var15 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Var16 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-			if !templ_7745c5c3_IsBuffer {
-				defer func() {
-					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err == nil {
-						templ_7745c5c3_Err = templ_7745c5c3_BufErr
-					}
-				}()
-			}
-			ctx = templ.InitializeContext(ctx)
-			templ_7745c5c3_Var17 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-				templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-				templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-				if !templ_7745c5c3_IsBuffer {
-					defer func() {
-						templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-						if templ_7745c5c3_Err == nil {
-							templ_7745c5c3_Err = templ_7745c5c3_BufErr
-						}
-					}()
-				}
-				ctx = templ.InitializeContext(ctx)
-				templ_7745c5c3_Var18 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-					templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-					templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-					if !templ_7745c5c3_IsBuffer {
-						defer func() {
-							templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-							if templ_7745c5c3_Err == nil {
-								templ_7745c5c3_Err = templ_7745c5c3_BufErr
-							}
-						}()
-					}
-					ctx = templ.InitializeContext(ctx)
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-progress-bar value=\"50\"></sl-progress-bar>")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					return templ_7745c5c3_Err
-				})
-				templ_7745c5c3_Err = form.Header().Render(templ.WithChildren(ctx, templ_7745c5c3_Var18), templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = input.Name().Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = input.Handle().Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = input.HumanSlider(data.FirstNumber, data.LastNumber).Render(ctx, templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Var19 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-					templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-					templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-					if !templ_7745c5c3_IsBuffer {
-						defer func() {
-							templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-							if templ_7745c5c3_Err == nil {
-								templ_7745c5c3_Err = templ_7745c5c3_BufErr
-							}
-						}()
-					}
-					ctx = templ.InitializeContext(ctx)
-					templ_7745c5c3_Err = form.CancelButton().Render(ctx, templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(" ")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					templ_7745c5c3_Err = form.SubmitButton("Next").Render(ctx, templ_7745c5c3_Buffer)
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					return templ_7745c5c3_Err
-				})
-				templ_7745c5c3_Err = form.Footer().Render(templ.WithChildren(ctx, templ_7745c5c3_Var19), templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				return templ_7745c5c3_Err
-			})
-			templ_7745c5c3_Err = form.Body().Render(templ.WithChildren(ctx, templ_7745c5c3_Var17), templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			return templ_7745c5c3_Err
-		})
-		templ_7745c5c3_Err = form.Root("/register/passkey", "POST", "create-profile").Render(templ.WithChildren(ctx, templ_7745c5c3_Var16), templ_7745c5c3_Buffer)
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
-
-var _ = templruntime.GeneratedTemplate

internal/models/Account.pkl.go

@@ -0,0 +1,20 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+type Account struct {
+	Id string `pkl:"id" json:"id,omitempty" query:"id"`
+
+	Name string `pkl:"name" json:"name,omitempty"`
+
+	Address any `pkl:"address" json:"address,omitempty"`
+
+	PublicKey string `pkl:"publicKey" json:"publicKey,omitempty"`
+
+	ChainCode uint `pkl:"chainCode" json:"chainCode,omitempty"`
+
+	Index int `pkl:"index" json:"index,omitempty"`
+
+	Controller string `pkl:"controller" json:"controller,omitempty"`
+
+	CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
+}

internal/models/Asset.pkl.go

@@ -0,0 +1,16 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+type Asset struct {
+	Id string `pkl:"id" json:"id,omitempty" query:"id"`
+
+	Name string `pkl:"name" json:"name,omitempty"`
+
+	Symbol string `pkl:"symbol" json:"symbol,omitempty"`
+
+	Decimals int `pkl:"decimals" json:"decimals,omitempty"`
+
+	ChainCode uint `pkl:"chainCode" json:"chainCode,omitempty"`
+
+	CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
+}

internal/models/Chain.pkl.go

@@ -0,0 +1,14 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+type Chain struct {
+	Id string `pkl:"id" json:"id,omitempty" query:"id"`
+
+	Name string `pkl:"name" json:"name,omitempty"`
+
+	NetworkId string `pkl:"networkId" json:"networkId,omitempty"`
+
+	ChainCode uint `pkl:"chainCode" json:"chainCode,omitempty"`
+
+	CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
+}

internal/models/Credential.pkl.go

@@ -0,0 +1,40 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+type Credential struct {
+	Id string `pkl:"id" json:"id,omitempty" query:"id"`
+
+	Subject string `pkl:"subject" json:"subject,omitempty"`
+
+	Controller string `pkl:"controller" json:"controller,omitempty"`
+
+	AttestationType string `pkl:"attestationType" json:"attestationType,omitempty"`
+
+	Origin string `pkl:"origin" json:"origin,omitempty"`
+
+	Label *string `pkl:"label" json:"label,omitempty"`
+
+	DeviceId *string `pkl:"deviceId" json:"deviceId,omitempty"`
+
+	CredentialId string `pkl:"credentialId" json:"credentialId,omitempty"`
+
+	PublicKey string `pkl:"publicKey" json:"publicKey,omitempty"`
+
+	Transport []string `pkl:"transport" json:"transport,omitempty"`
+
+	SignCount uint `pkl:"signCount" json:"signCount,omitempty"`
+
+	UserPresent bool `pkl:"userPresent" json:"userPresent,omitempty"`
+
+	UserVerified bool `pkl:"userVerified" json:"userVerified,omitempty"`
+
+	BackupEligible bool `pkl:"backupEligible" json:"backupEligible,omitempty"`
+
+	BackupState bool `pkl:"backupState" json:"backupState,omitempty"`
+
+	CloneWarning bool `pkl:"cloneWarning" json:"cloneWarning,omitempty"`
+
+	CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
+
+	UpdatedAt *string `pkl:"updatedAt" json:"updatedAt,omitempty"`
+}

internal/models/DID.pkl.go

@@ -0,0 +1,28 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+import (
+	"github.com/onsonr/sonr/internal/models/keyalgorithm"
+	"github.com/onsonr/sonr/internal/models/keycurve"
+	"github.com/onsonr/sonr/internal/models/keyencoding"
+	"github.com/onsonr/sonr/internal/models/keyrole"
+	"github.com/onsonr/sonr/internal/models/keytype"
+)
+
+type DID struct {
+	Id string `pkl:"id" json:"id,omitempty" query:"id"`
+
+	Role keyrole.KeyRole `pkl:"role"`
+
+	Algorithm keyalgorithm.KeyAlgorithm `pkl:"algorithm"`
+
+	Encoding keyencoding.KeyEncoding `pkl:"encoding"`
+
+	Curve keycurve.KeyCurve `pkl:"curve"`
+
+	KeyType keytype.KeyType `pkl:"key_type"`
+
+	Raw string `pkl:"raw"`
+
+	Jwk *JWK `pkl:"jwk"`
+}

internal/models/Grant.pkl.go

@@ -0,0 +1,20 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+type Grant struct {
+	Id uint `pkl:"id" json:"id,omitempty" query:"id"`
+
+	Subject string `pkl:"subject" json:"subject,omitempty"`
+
+	Controller string `pkl:"controller" json:"controller,omitempty"`
+
+	Origin string `pkl:"origin" json:"origin,omitempty"`
+
+	Token string `pkl:"token" json:"token,omitempty"`
+
+	Scopes []string `pkl:"scopes" json:"scopes,omitempty"`
+
+	CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
+
+	UpdatedAt *string `pkl:"updatedAt" json:"updatedAt,omitempty"`
+}

internal/models/JWK.pkl.go

@@ -0,0 +1,16 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+type JWK struct {
+	Kty string `pkl:"kty" json:"kty,omitempty"`
+
+	Crv string `pkl:"crv" json:"crv,omitempty"`
+
+	X string `pkl:"x" json:"x,omitempty"`
+
+	Y string `pkl:"y" json:"y,omitempty"`
+
+	N string `pkl:"n" json:"n,omitempty"`
+
+	E string `pkl:"e" json:"e,omitempty"`
+}

internal/models/Keyshare.pkl.go

@@ -0,0 +1,14 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+type Keyshare struct {
+	Id string `pkl:"id" json:"id,omitempty" query:"id"`
+
+	Data string `pkl:"data" json:"data,omitempty"`
+
+	Role int `pkl:"role" json:"role,omitempty"`
+
+	CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
+
+	LastRefreshed *string `pkl:"lastRefreshed" json:"lastRefreshed,omitempty"`
+}

internal/models/Models.pkl.go

@@ -0,0 +1,39 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+import (
+	"context"
+
+	"github.com/apple/pkl-go/pkl"
+)
+
+type Models struct {
+	DbName string `pkl:"db_name"`
+
+	DbVersion int `pkl:"db_version"`
+}
+
+// LoadFromPath loads the pkl module at the given path and evaluates it into a Models
+func LoadFromPath(ctx context.Context, path string) (ret *Models, err error) {
+	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		cerr := evaluator.Close()
+		if err == nil {
+			err = cerr
+		}
+	}()
+	ret, err = Load(ctx, evaluator, pkl.FileSource(path))
+	return ret, err
+}
+
+// Load loads the pkl module at the given source and evaluates it with the given evaluator into a Models
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Models, error) {
+	var ret Models
+	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
+		return nil, err
+	}
+	return &ret, nil
+}

internal/models/Profile.pkl.go

@@ -0,0 +1,20 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+type Profile struct {
+	Id string `pkl:"id" json:"id,omitempty" query:"id"`
+
+	Subject string `pkl:"subject" json:"subject,omitempty"`
+
+	Controller string `pkl:"controller" json:"controller,omitempty"`
+
+	OriginUri *string `pkl:"originUri" json:"originUri,omitempty"`
+
+	PublicMetadata *string `pkl:"publicMetadata" json:"publicMetadata,omitempty"`
+
+	PrivateMetadata *string `pkl:"privateMetadata" json:"privateMetadata,omitempty"`
+
+	CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
+
+	UpdatedAt *string `pkl:"updatedAt" json:"updatedAt,omitempty"`
+}

internal/models/assettype/AssetType.pkl.go

@@ -0,0 +1,46 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package assettype
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type AssetType string
+
+const (
+	Native  AssetType = "native"
+	Wrapped AssetType = "wrapped"
+	Staking AssetType = "staking"
+	Pool    AssetType = "pool"
+	Ibc     AssetType = "ibc"
+	Cw20    AssetType = "cw20"
+)
+
+// String returns the string representation of AssetType
+func (rcv AssetType) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(AssetType)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for AssetType.
+func (rcv *AssetType) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "native":
+		*rcv = Native
+	case "wrapped":
+		*rcv = Wrapped
+	case "staking":
+		*rcv = Staking
+	case "pool":
+		*rcv = Pool
+	case "ibc":
+		*rcv = Ibc
+	case "cw20":
+		*rcv = Cw20
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid AssetType`, str)
+	}
+	return nil
+}

internal/models/didmethod/DIDMethod.pkl.go

@@ -0,0 +1,52 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package didmethod
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type DIDMethod string
+
+const (
+	Ipfs     DIDMethod = "ipfs"
+	Sonr     DIDMethod = "sonr"
+	Bitcoin  DIDMethod = "bitcoin"
+	Ethereum DIDMethod = "ethereum"
+	Ibc      DIDMethod = "ibc"
+	Webauthn DIDMethod = "webauthn"
+	Dwn      DIDMethod = "dwn"
+	Service  DIDMethod = "service"
+)
+
+// String returns the string representation of DIDMethod
+func (rcv DIDMethod) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(DIDMethod)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for DIDMethod.
+func (rcv *DIDMethod) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "ipfs":
+		*rcv = Ipfs
+	case "sonr":
+		*rcv = Sonr
+	case "bitcoin":
+		*rcv = Bitcoin
+	case "ethereum":
+		*rcv = Ethereum
+	case "ibc":
+		*rcv = Ibc
+	case "webauthn":
+		*rcv = Webauthn
+	case "dwn":
+		*rcv = Dwn
+	case "service":
+		*rcv = Service
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid DIDMethod`, str)
+	}
+	return nil
+}

internal/models/init.pkl.go

@@ -0,0 +1,17 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package models
+
+import "github.com/apple/pkl-go/pkl"
+
+func init() {
+	pkl.RegisterMapping("sonr.orm.Models", Models{})
+	pkl.RegisterMapping("sonr.orm.Models#Account", Account{})
+	pkl.RegisterMapping("sonr.orm.Models#Asset", Asset{})
+	pkl.RegisterMapping("sonr.orm.Models#Chain", Chain{})
+	pkl.RegisterMapping("sonr.orm.Models#Credential", Credential{})
+	pkl.RegisterMapping("sonr.orm.Models#DID", DID{})
+	pkl.RegisterMapping("sonr.orm.Models#JWK", JWK{})
+	pkl.RegisterMapping("sonr.orm.Models#Grant", Grant{})
+	pkl.RegisterMapping("sonr.orm.Models#Keyshare", Keyshare{})
+	pkl.RegisterMapping("sonr.orm.Models#Profile", Profile{})
+}

internal/models/keyalgorithm/KeyAlgorithm.pkl.go

@@ -0,0 +1,46 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package keyalgorithm
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type KeyAlgorithm string
+
+const (
+	Es256  KeyAlgorithm = "es256"
+	Es384  KeyAlgorithm = "es384"
+	Es512  KeyAlgorithm = "es512"
+	Eddsa  KeyAlgorithm = "eddsa"
+	Es256k KeyAlgorithm = "es256k"
+	Ecdsa  KeyAlgorithm = "ecdsa"
+)
+
+// String returns the string representation of KeyAlgorithm
+func (rcv KeyAlgorithm) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(KeyAlgorithm)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyAlgorithm.
+func (rcv *KeyAlgorithm) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "es256":
+		*rcv = Es256
+	case "es384":
+		*rcv = Es384
+	case "es512":
+		*rcv = Es512
+	case "eddsa":
+		*rcv = Eddsa
+	case "es256k":
+		*rcv = Es256k
+	case "ecdsa":
+		*rcv = Ecdsa
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid KeyAlgorithm`, str)
+	}
+	return nil
+}

internal/models/keycurve/KeyCurve.pkl.go

@@ -0,0 +1,58 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package keycurve
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type KeyCurve string
+
+const (
+	P256      KeyCurve = "p256"
+	P384      KeyCurve = "p384"
+	P521      KeyCurve = "p521"
+	X25519    KeyCurve = "x25519"
+	X448      KeyCurve = "x448"
+	Ed25519   KeyCurve = "ed25519"
+	Ed448     KeyCurve = "ed448"
+	Secp256k1 KeyCurve = "secp256k1"
+	Bls12381  KeyCurve = "bls12381"
+	Keccak256 KeyCurve = "keccak256"
+)
+
+// String returns the string representation of KeyCurve
+func (rcv KeyCurve) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(KeyCurve)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyCurve.
+func (rcv *KeyCurve) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "p256":
+		*rcv = P256
+	case "p384":
+		*rcv = P384
+	case "p521":
+		*rcv = P521
+	case "x25519":
+		*rcv = X25519
+	case "x448":
+		*rcv = X448
+	case "ed25519":
+		*rcv = Ed25519
+	case "ed448":
+		*rcv = Ed448
+	case "secp256k1":
+		*rcv = Secp256k1
+	case "bls12381":
+		*rcv = Bls12381
+	case "keccak256":
+		*rcv = Keccak256
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid KeyCurve`, str)
+	}
+	return nil
+}

internal/models/keyencoding/KeyEncoding.pkl.go

@@ -0,0 +1,37 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package keyencoding
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type KeyEncoding string
+
+const (
+	Raw       KeyEncoding = "raw"
+	Hex       KeyEncoding = "hex"
+	Multibase KeyEncoding = "multibase"
+)
+
+// String returns the string representation of KeyEncoding
+func (rcv KeyEncoding) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(KeyEncoding)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyEncoding.
+func (rcv *KeyEncoding) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "raw":
+		*rcv = Raw
+	case "hex":
+		*rcv = Hex
+	case "multibase":
+		*rcv = Multibase
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid KeyEncoding`, str)
+	}
+	return nil
+}

internal/models/keyrole/KeyRole.pkl.go

@@ -0,0 +1,40 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package keyrole
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type KeyRole string
+
+const (
+	Authentication KeyRole = "authentication"
+	Assertion      KeyRole = "assertion"
+	Delegation     KeyRole = "delegation"
+	Invocation     KeyRole = "invocation"
+)
+
+// String returns the string representation of KeyRole
+func (rcv KeyRole) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(KeyRole)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyRole.
+func (rcv *KeyRole) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "authentication":
+		*rcv = Authentication
+	case "assertion":
+		*rcv = Assertion
+	case "delegation":
+		*rcv = Delegation
+	case "invocation":
+		*rcv = Invocation
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid KeyRole`, str)
+	}
+	return nil
+}

internal/models/keysharerole/KeyShareRole.pkl.go

@@ -0,0 +1,34 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package keysharerole
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type KeyShareRole string
+
+const (
+	User      KeyShareRole = "user"
+	Validator KeyShareRole = "validator"
+)
+
+// String returns the string representation of KeyShareRole
+func (rcv KeyShareRole) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(KeyShareRole)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyShareRole.
+func (rcv *KeyShareRole) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "user":
+		*rcv = User
+	case "validator":
+		*rcv = Validator
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid KeyShareRole`, str)
+	}
+	return nil
+}

internal/models/keytype/KeyType.pkl.go

@@ -0,0 +1,55 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package keytype
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type KeyType string
+
+const (
+	Octet     KeyType = "octet"
+	Elliptic  KeyType = "elliptic"
+	Rsa       KeyType = "rsa"
+	Symmetric KeyType = "symmetric"
+	Hmac      KeyType = "hmac"
+	Mpc       KeyType = "mpc"
+	Zk        KeyType = "zk"
+	Webauthn  KeyType = "webauthn"
+	Bip32     KeyType = "bip32"
+)
+
+// String returns the string representation of KeyType
+func (rcv KeyType) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(KeyType)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyType.
+func (rcv *KeyType) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "octet":
+		*rcv = Octet
+	case "elliptic":
+		*rcv = Elliptic
+	case "rsa":
+		*rcv = Rsa
+	case "symmetric":
+		*rcv = Symmetric
+	case "hmac":
+		*rcv = Hmac
+	case "mpc":
+		*rcv = Mpc
+	case "zk":
+		*rcv = Zk
+	case "webauthn":
+		*rcv = Webauthn
+	case "bip32":
+		*rcv = Bip32
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid KeyType`, str)
+	}
+	return nil
+}

internal/models/permissiongrant/PermissionGrant.pkl.go

@@ -0,0 +1,46 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package permissiongrant
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type PermissionGrant string
+
+const (
+	None      PermissionGrant = "none"
+	Read      PermissionGrant = "read"
+	Write     PermissionGrant = "write"
+	Verify    PermissionGrant = "verify"
+	Broadcast PermissionGrant = "broadcast"
+	Admin     PermissionGrant = "admin"
+)
+
+// String returns the string representation of PermissionGrant
+func (rcv PermissionGrant) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(PermissionGrant)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for PermissionGrant.
+func (rcv *PermissionGrant) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "none":
+		*rcv = None
+	case "read":
+		*rcv = Read
+	case "write":
+		*rcv = Write
+	case "verify":
+		*rcv = Verify
+	case "broadcast":
+		*rcv = Broadcast
+	case "admin":
+		*rcv = Admin
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid PermissionGrant`, str)
+	}
+	return nil
+}

internal/models/permissionscope/PermissionScope.pkl.go

@@ -0,0 +1,49 @@
+// Code generated from Pkl module `sonr.orm.Models`. DO NOT EDIT.
+package permissionscope
+
+import (
+	"encoding"
+	"fmt"
+)
+
+type PermissionScope string
+
+const (
+	Profile      PermissionScope = "profile"
+	Metadata     PermissionScope = "metadata"
+	Permissions  PermissionScope = "permissions"
+	Wallets      PermissionScope = "wallets"
+	Transactions PermissionScope = "transactions"
+	User         PermissionScope = "user"
+	Validator    PermissionScope = "validator"
+)
+
+// String returns the string representation of PermissionScope
+func (rcv PermissionScope) String() string {
+	return string(rcv)
+}
+
+var _ encoding.BinaryUnmarshaler = new(PermissionScope)
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler for PermissionScope.
+func (rcv *PermissionScope) UnmarshalBinary(data []byte) error {
+	switch str := string(data); str {
+	case "profile":
+		*rcv = Profile
+	case "metadata":
+		*rcv = Metadata
+	case "permissions":
+		*rcv = Permissions
+	case "wallets":
+		*rcv = Wallets
+	case "transactions":
+		*rcv = Transactions
+	case "user":
+		*rcv = User
+	case "validator":
+		*rcv = Validator
+	default:
+		return fmt.Errorf(`illegal: "%s" is not a valid PermissionScope`, str)
+	}
+	return nil
+}

internal/models/webworker.go

@@ -0,0 +1,124 @@
+package models
+
+import "encoding/json"
+
+func NewWebManifest() ([]byte, error) {
+	return json.Marshal(baseWebManifest)
+}
+
+var baseWebManifest = WebManifest{
+	Name:      "Sonr Vault",
+	ShortName: "Sonr.ID",
+	StartURL:  "/index.html",
+	Display:   "standalone",
+	DisplayOverride: []string{
+		"fullscreen",
+		"minimal-ui",
+	},
+	Icons: []IconDefinition{
+		{
+			Src:   "/icons/icon-192x192.png",
+			Sizes: "192x192",
+			Type:  "image/png",
+		},
+	},
+	ServiceWorker: ServiceWorker{
+		Scope:    "/",
+		Src:      "/sw.js",
+		UseCache: true,
+	},
+	ProtocolHandlers: []ProtocolHandler{
+		{
+			Scheme: "did.sonr",
+			URL:    "/resolve/sonr/%s",
+		},
+		{
+			Scheme: "did.eth",
+			URL:    "/resolve/eth/%s",
+		},
+		{
+			Scheme: "did.btc",
+			URL:    "/resolve/btc/%s",
+		},
+		{
+			Scheme: "did.usdc",
+			URL:    "/resolve/usdc/%s",
+		},
+		{
+			Scheme: "did.ipfs",
+			URL:    "/resolve/ipfs/%s",
+		},
+	},
+}
+
+type WebManifest struct {
+	// Required fields
+	Name      string `json:"name"`       // Full name of the application
+	ShortName string `json:"short_name"` // Short version of the name
+
+	// Display and appearance
+	Description     string   `json:"description,omitempty"` // Purpose and features of the application
+	Display         string   `json:"display,omitempty"`     // Preferred display mode: fullscreen, standalone, minimal-ui, browser
+	DisplayOverride []string `json:"display_override,omitempty"`
+	ThemeColor      string   `json:"theme_color,omitempty"`      // Default theme color for the application
+	BackgroundColor string   `json:"background_color,omitempty"` // Background color during launch
+	Orientation     string   `json:"orientation,omitempty"`      // Default orientation: any, natural, landscape, portrait
+
+	// URLs and scope
+	StartURL      string        `json:"start_url"`       // Starting URL when launching
+	Scope         string        `json:"scope,omitempty"` // Navigation scope of the web application
+	ServiceWorker ServiceWorker `json:"service_worker,omitempty"`
+
+	// Icons
+	Icons []IconDefinition `json:"icons,omitempty"`
+
+	// Optional features
+	RelatedApplications       []RelatedApplication `json:"related_applications,omitempty"`
+	PreferRelatedApplications bool                 `json:"prefer_related_applications,omitempty"`
+	Shortcuts                 []Shortcut           `json:"shortcuts,omitempty"`
+
+	// Experimental features (uncomment if needed)
+	FileHandlers     []FileHandler     `json:"file_handlers,omitempty"`
+	ProtocolHandlers []ProtocolHandler `json:"protocol_handlers,omitempty"`
+}
+
+type FileHandler struct {
+	Action string              `json:"action"`
+	Accept map[string][]string `json:"accept"`
+}
+
+type LaunchHandler struct {
+	Action string `json:"action"`
+}
+
+type IconDefinition struct {
+	Src     string `json:"src"`
+	Sizes   string `json:"sizes"`
+	Type    string `json:"type,omitempty"`
+	Purpose string `json:"purpose,omitempty"`
+}
+
+type ProtocolHandler struct {
+	Scheme string `json:"scheme"`
+	URL    string `json:"url"`
+}
+
+type RelatedApplication struct {
+	Platform string `json:"platform"`
+	URL      string `json:"url,omitempty"`
+	ID       string `json:"id,omitempty"`
+}
+
+type Shortcut struct {
+	Name        string           `json:"name"`
+	ShortName   string           `json:"short_name,omitempty"`
+	Description string           `json:"description,omitempty"`
+	URL         string           `json:"url"`
+	Icons       []IconDefinition `json:"icons,omitempty"`
+}
+
+type ServiceWorker struct {
+	Scope    string `json:"scope"`
+	Src      string `json:"src"`
+	UseCache bool   `json:"use_cache"`
+}

internal/nebula/form/base.templ

@@ -1,7 +1,7 @@
 package form
 
-templ Root(action, method, id string) {
-	<form action={ templ.SafeURL(action) } method={ method } id={ id }>
+templ Root(action, id string) {
+	<form hx-post={ action } hx-target="#{ id }" hx-swap="outerHTML">
 		{ children... }
 	</form>
 }

internal/nebula/form/base_templ.go

@@ -8,7 +8,7 @@ package form
 import "github.com/a-h/templ"
 import templruntime "github.com/a-h/templ/runtime"
 
-func Root(action, method, id string) templ.Component {
+func Root(action, id string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -29,42 +29,20 @@ func Root(action, method, id string) templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<form action=\"")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<form hx-post=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var2 templ.SafeURL = templ.SafeURL(action)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(string(templ_7745c5c3_Var2)))
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(action)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/form/base.templ`, Line: 4, Col: 23}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" method=\"")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var3 string
-		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(method)
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/form/base.templ`, Line: 4, Col: 55}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" id=\"")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var4 string
-		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(id)
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/form/base.templ`, Line: 4, Col: 65}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\">")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" hx-target=\"#{ id }\" hx-swap=\"outerHTML\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -96,16 +74,16 @@ func Header() templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var5 == nil {
-			templ_7745c5c3_Var5 = templ.NopComponent
+		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var3 == nil {
+			templ_7745c5c3_Var3 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div slot=\"header\"><div class=\"w-full py-2\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templ_7745c5c3_Var5.Render(ctx, templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = templ_7745c5c3_Var3.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -133,16 +111,16 @@ func Body() templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var6 == nil {
-			templ_7745c5c3_Var6 = templ.NopComponent
+		templ_7745c5c3_Var4 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var4 == nil {
+			templ_7745c5c3_Var4 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-card class=\"card-form max-w-lg mx-auto\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templ_7745c5c3_Var6.Render(ctx, templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = templ_7745c5c3_Var4.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -170,16 +148,16 @@ func Footer() templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var7 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var7 == nil {
-			templ_7745c5c3_Var7 = templ.NopComponent
+		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var5 == nil {
+			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div slot=\"footer\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templ_7745c5c3_Var7.Render(ctx, templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = templ_7745c5c3_Var5.Render(ctx, templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -207,9 +185,9 @@ func CancelButton() templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var8 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var8 == nil {
-			templ_7745c5c3_Var8 = templ.NopComponent
+		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var6 == nil {
+			templ_7745c5c3_Var6 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button href=\"/\" outline><sl-icon slot=\"prefix\" name=\"x-lg\"></sl-icon> Cancel</sl-button>")
@@ -236,21 +214,21 @@ func SubmitButton(text string) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var9 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var9 == nil {
-			templ_7745c5c3_Var9 = templ.NopComponent
+		templ_7745c5c3_Var7 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var7 == nil {
+			templ_7745c5c3_Var7 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-button type=\"submit\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var10 string
-		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(text)
+		var templ_7745c5c3_Var8 string
+		templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(text)
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/form/base.templ`, Line: 55, Col: 8}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

internal/nebula/input/input_handle.templ

@@ -13,8 +13,8 @@ func (s HandleState) string() string {
 }
 
 templ Handle() {
-	<div>
-		<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required>
+	<div hx-target="this" hx-swap="outerHTML">
+		<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required hx-post="/register/profile/handle" hx-indicator="#handle-indicator" autofocus>
 			<div slot="prefix">
 				<sl-icon name="at-sign" library="sonr"></sl-icon>
 			</div>
@@ -23,20 +23,20 @@ templ Handle() {
 	<br/>
 }
 
-templ HandleError() {
-	<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required class="border-red-500">
+templ HandleError(value string) {
+	<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required class="border-red-500" value={ value }>
 		<div slot="prefix">
 			<sl-icon name="at-sign" library="sonr"></sl-icon>
 		</div>
 		<div slot="suffix" style="color: #B54549;">
-			<sl-icon name="at-sign" library="sonr"></sl-icon>
+			<sl-icon name="x"></sl-icon>
 		</div>
 	</sl-input>
 	<br/>
 }
 
-templ HandleValid() {
-	<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required class="border-green-500">
+templ HandleSuccess(value string) {
+	<sl-input name="handle" placeholder="digitalgold" type="text" label="Handle" minlength="4" maxlength="12" required class="border-green-500" value={ value } disabled>
 		<div slot="prefix" style="color: #46A758;">
 			<sl-icon name="at-sign" library="sonr"></sl-icon>
 		</div>

internal/nebula/input/input_handle_templ.go

@@ -41,7 +41,7 @@ func Handle() templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div><sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required><div slot=\"prefix\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div></sl-input></div><br>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div hx-target=\"this\" hx-swap=\"outerHTML\"><sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required hx-post=\"/register/profile/handle\" hx-indicator=\"#handle-indicator\" autofocus><div slot=\"prefix\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div></sl-input></div><br>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -49,7 +49,7 @@ func Handle() templ.Component {
 	})
 }
 
-func HandleError() templ.Component {
+func HandleError(value string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -70,7 +70,20 @@ func HandleError() templ.Component {
 			templ_7745c5c3_Var2 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required class=\"border-red-500\"><div slot=\"prefix\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div><div slot=\"suffix\" style=\"color: #B54549;\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div></sl-input><br>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required class=\"border-red-500\" value=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var3 string
+		templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(value)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/input/input_handle.templ`, Line: 27, Col: 152}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"><div slot=\"prefix\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div><div slot=\"suffix\" style=\"color: #B54549;\"><sl-icon name=\"x\"></sl-icon></div></sl-input><br>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -78,7 +91,7 @@ func HandleError() templ.Component {
 	})
 }
 
-func HandleValid() templ.Component {
+func HandleSuccess(value string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -94,12 +107,25 @@ func HandleValid() templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var3 == nil {
-			templ_7745c5c3_Var3 = templ.NopComponent
+		templ_7745c5c3_Var4 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var4 == nil {
+			templ_7745c5c3_Var4 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required class=\"border-green-500\"><div slot=\"prefix\" style=\"color: #46A758;\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div></sl-input><br>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-input name=\"handle\" placeholder=\"digitalgold\" type=\"text\" label=\"Handle\" minlength=\"4\" maxlength=\"12\" required class=\"border-green-500\" value=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var5 string
+		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(value)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/input/input_handle.templ`, Line: 39, Col: 154}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" disabled><div slot=\"prefix\" style=\"color: #46A758;\"><sl-icon name=\"at-sign\" library=\"sonr\"></sl-icon></div></sl-input><br>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

internal/nebula/input/input_ishuman.templ

@@ -0,0 +1,25 @@
+package input
+
+import "fmt"
+
+templ HumanSlider(firstNumber int, lastNumber int) {
+	<div hx-target="this" hx-swap="outerHTML">
+		<sl-range name="is_human" label={ humanLabel(firstNumber, lastNumber) } help-text="Prove you are a human." min="0" max="9" step="1" hx-post="/register/profile/is_human"></sl-range>
+	</div>
+}
+
+templ HumanSliderError(firstNumber int, lastNumber int) {
+	<sl-range name="is_human" label={ humanLabel(firstNumber, lastNumber) } help-text="Prove you are a human." min="0" max="9" step="1"></sl-range>
+	<div slot="help-text">
+		<sl-icon name="x-lg" library="sonr"></sl-icon>
+		Invalid Human Sum
+	</div>
+}
+
+templ HumanSliderSuccess() {
+	<sl-range name="is_human" label="Success! Welcome Human." help-text="Prove you are a human." min="0" max="9" step="1" value="9" disabled></sl-range>
+}
+
+func humanLabel(firstNumber int, lastNumber int) string {
+	return fmt.Sprintf("What is %d + %d?", firstNumber, lastNumber)
+}

internal/nebula/input/input_ishuman_templ.go

@@ -0,0 +1,130 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.2.793
+package input
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import "fmt"
+
+func HumanSlider(firstNumber int, lastNumber int) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
+			return templ_7745c5c3_CtxErr
+		}
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div hx-target=\"this\" hx-swap=\"outerHTML\"><sl-range name=\"is_human\" label=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(humanLabel(firstNumber, lastNumber))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/input/input_ishuman.templ`, Line: 7, Col: 71}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" help-text=\"Prove you are a human.\" min=\"0\" max=\"9\" step=\"1\" hx-post=\"/register/profile/is_human\"></sl-range></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func HumanSliderError(firstNumber int, lastNumber int) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
+			return templ_7745c5c3_CtxErr
+		}
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var3 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var3 == nil {
+			templ_7745c5c3_Var3 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-range name=\"is_human\" label=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var4 string
+		templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(humanLabel(firstNumber, lastNumber))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/input/input_ishuman.templ`, Line: 12, Col: 70}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" help-text=\"Prove you are a human.\" min=\"0\" max=\"9\" step=\"1\"></sl-range><div slot=\"help-text\"><sl-icon name=\"x-lg\" library=\"sonr\"></sl-icon> Invalid Human Sum</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func HumanSliderSuccess() templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
+			return templ_7745c5c3_CtxErr
+		}
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var5 == nil {
+			templ_7745c5c3_Var5 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-range name=\"is_human\" label=\"Success! Welcome Human.\" help-text=\"Prove you are a human.\" min=\"0\" max=\"9\" step=\"1\" value=\"9\" disabled></sl-range>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return templ_7745c5c3_Err
+	})
+}
+
+func humanLabel(firstNumber int, lastNumber int) string {
+	return fmt.Sprintf("What is %d + %d?", firstNumber, lastNumber)
+}
+
+var _ = templruntime.GeneratedTemplate

internal/nebula/input/input_name.templ

@@ -14,7 +14,7 @@ func (s NameState) string() string {
 
 templ Name() {
 	<div hx-target="this" hx-swap="outerHTML" class="grid grid-cols-1 lg:grid-cols-2 gap-4">
-		<sl-input name="first_name" placeholder="Satoshi" type="text" label="First Name" required autofocus></sl-input>
+		<sl-input name="first_name" placeholder="Satoshi" type="text" label="First Name" required></sl-input>
 		<sl-input name="last_name" placeholder="N" maxlength="1" type="text" label="Last Initial"></sl-input>
 	</div>
 	<br/>

internal/nebula/input/input_name_templ.go

@@ -41,7 +41,7 @@ func Name() templ.Component {
 			templ_7745c5c3_Var1 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div hx-target=\"this\" hx-swap=\"outerHTML\" class=\"grid grid-cols-1 lg:grid-cols-2 gap-4\"><sl-input name=\"first_name\" placeholder=\"Satoshi\" type=\"text\" label=\"First Name\" required autofocus></sl-input> <sl-input name=\"last_name\" placeholder=\"N\" maxlength=\"1\" type=\"text\" label=\"Last Initial\"></sl-input></div><br>")
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<div hx-target=\"this\" hx-swap=\"outerHTML\" class=\"grid grid-cols-1 lg:grid-cols-2 gap-4\"><sl-input name=\"first_name\" placeholder=\"Satoshi\" type=\"text\" label=\"First Name\" required></sl-input> <sl-input name=\"last_name\" placeholder=\"N\" maxlength=\"1\" type=\"text\" label=\"Last Initial\"></sl-input></div><br>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

internal/nebula/input/input_passkey.templ

@@ -39,6 +39,9 @@ script navigatorCredentialsCreate(userId string, userHandle string, challenge st
       payment: {
         isPayment: true,
       },
+      largeBlob: {
+        supported: "preferred",
+      },
     },
   };
 

internal/nebula/input/input_passkey_templ.go

@@ -52,8 +52,8 @@ func Passkey(addr string, userHandle string, challenge string) templ.Component {
 
 func navigatorCredentialsCreate(userId string, userHandle string, challenge string) templ.ComponentScript {
 	return templ.ComponentScript{
-		Name: `__templ_navigatorCredentialsCreate_7340`,
-		Function: `function __templ_navigatorCredentialsCreate_7340(userId, userHandle, challenge){const publicKey = {
+		Name: `__templ_navigatorCredentialsCreate_63c0`,
+		Function: `function __templ_navigatorCredentialsCreate_63c0(userId, userHandle, challenge){const publicKey = {
     challenge: Uint8Array.from(challenge, (c) => c.charCodeAt(0)),
     rp: {
       name: "Sonr.ID",
@@ -84,6 +84,9 @@ func navigatorCredentialsCreate(userId string, userHandle string, challenge stri
       payment: {
         isPayment: true,
       },
+      largeBlob: {
+        supported: "preferred",
+      },
     },
   };
 
@@ -137,8 +140,8 @@ navigator.credentials
     alert(` + "`" + `Failed to create passkey: ${err.message || 'Unknown error'}` + "`" + `);
   });
 }`,
-		Call:       templ.SafeScript(`__templ_navigatorCredentialsCreate_7340`, userId, userHandle, challenge),
-		CallInline: templ.SafeScriptInline(`__templ_navigatorCredentialsCreate_7340`, userId, userHandle, challenge),
+		Call:       templ.SafeScript(`__templ_navigatorCredentialsCreate_63c0`, userId, userHandle, challenge),
+		CallInline: templ.SafeScriptInline(`__templ_navigatorCredentialsCreate_63c0`, userId, userHandle, challenge),
 	}
 }
 

internal/nebula/input/slider_isHuman.templ

@@ -1,11 +0,0 @@
-package input
-
-import "fmt"
-
-templ HumanSlider(firstNumber int, lastNumber int) {
-	<sl-range name="is_human" label={ formatHumanSliderLabel(firstNumber, lastNumber) } help-text="Prove you are a human." min="0" max="9" step="1"></sl-range>
-}
-
-func formatHumanSliderLabel(firstNumber int, lastNumber int) string {
-	return fmt.Sprintf("What is %d + %d?", firstNumber, lastNumber)
-}

internal/nebula/input/slider_isHuman_templ.go

@@ -1,59 +0,0 @@
-// Code generated by templ - DO NOT EDIT.
-
-// templ: version: v0.2.793
-package input
-
-//lint:file-ignore SA4006 This context is only used if a nested component is present.
-
-import "github.com/a-h/templ"
-import templruntime "github.com/a-h/templ/runtime"
-
-import "fmt"
-
-func HumanSlider(firstNumber int, lastNumber int) templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var1 == nil {
-			templ_7745c5c3_Var1 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<sl-range name=\"is_human\" label=\"")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var2 string
-		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(formatHumanSliderLabel(firstNumber, lastNumber))
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/input/slider_isHuman.templ`, Line: 6, Col: 82}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\" help-text=\"Prove you are a human.\" min=\"0\" max=\"9\" step=\"1\"></sl-range>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		return templ_7745c5c3_Err
-	})
-}
-
-func formatHumanSliderLabel(firstNumber int, lastNumber int) string {
-	return fmt.Sprintf("What is %d + %d?", firstNumber, lastNumber)
-}
-
-var _ = templruntime.GeneratedTemplate

internal/nebula/layout/head.templ

@@ -103,6 +103,8 @@ templ Htmx() {
 		<script src={ jsDelivrURL("htmx-ext-include-vals", "2.0.0", "include-vals.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-path-params", "2.0.0", "path-params.min.js") }></script>
 		<script src={ jsDelivrURL("htmx-ext-alpine-morph", "2.0.0", "alpine-morph.min.js") }></script>
+		<script src={ jsDelivrURL("htmx-ext-sse", "2.2.2", "sse.min.js") }></script>
+		<script src={ jsDelivrURL("htmx-ext-ws", "2.0.2", "ws.min.js") }></script>
 	}
 }
 

internal/nebula/layout/head_templ.go

@@ -431,6 +431,32 @@ func Htmx() templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var21 string
+			templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-sse", "2.2.2", "sse.min.js"))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/layout/head.templ`, Line: 106, Col: 66}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script> <script src=\"")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var22 string
+			templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("htmx-ext-ws", "2.0.2", "ws.min.js"))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/layout/head.templ`, Line: 107, Col: 64}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("\"></script>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
@@ -462,21 +488,21 @@ func Nebula(version string) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var21 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var21 == nil {
-			templ_7745c5c3_Var21 = templ.NopComponent
+		templ_7745c5c3_Var23 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var23 == nil {
+			templ_7745c5c3_Var23 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString("<link rel=\"stylesheet\" media=\"(prefers-color-scheme:light)\" href=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var22 string
-		templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/light.css"))
+		var templ_7745c5c3_Var24 string
+		templ_7745c5c3_Var24, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/light.css"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/layout/head.templ`, Line: 114, Col: 71}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/layout/head.templ`, Line: 116, Col: 71}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var24))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -484,12 +510,12 @@ func Nebula(version string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var23 string
-		templ_7745c5c3_Var23, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/dark.css"))
+		var templ_7745c5c3_Var25 string
+		templ_7745c5c3_Var25, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/themes/dark.css"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/layout/head.templ`, Line: 119, Col: 70}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/layout/head.templ`, Line: 121, Col: 70}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var23))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var25))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -497,7 +523,7 @@ func Nebula(version string) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Var24 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_Var26 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
 			if !templ_7745c5c3_IsBuffer {
@@ -513,12 +539,12 @@ func Nebula(version string) templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			var templ_7745c5c3_Var25 string
-			templ_7745c5c3_Var25, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/shoelace-autoloader.js"))
+			var templ_7745c5c3_Var27 string
+			templ_7745c5c3_Var27, templ_7745c5c3_Err = templ.JoinStringErrs(jsDelivrURL("@onsonr/nebula", version, "cdn/shoelace-autoloader.js"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/layout/head.templ`, Line: 123, Col: 98}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/nebula/layout/head.templ`, Line: 125, Col: 98}
 			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var25))
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var27))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -528,7 +554,7 @@ func Nebula(version string) templ.Component {
 			}
 			return templ_7745c5c3_Err
 		})
-		templ_7745c5c3_Err = nebulaHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var24), templ_7745c5c3_Buffer)
+		templ_7745c5c3_Err = nebulaHandle.Once().Render(templ.WithChildren(ctx, templ_7745c5c3_Var26), templ_7745c5c3_Buffer)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

internal/vault/context/context.go

@@ -1,156 +0,0 @@
-package context
-
-import (
-	"regexp"
-	"strings"
-
-	"github.com/go-webauthn/webauthn/protocol"
-	"github.com/go-webauthn/webauthn/protocol/webauthncose"
-	"github.com/labstack/echo/v4"
-	"github.com/segmentio/ksuid"
-
-	"github.com/onsonr/sonr/pkg/common"
-)
-
-const kWebAuthnTimeout = 6000
-
-// TODO: Returns fixed chain ID for testing.
-func GetChainID(c echo.Context) string {
-	return "sonr-testnet-1"
-}
-
-// SetVaultAddress sets the address of the vault
-func SetVaultAddress(c echo.Context, address string) error {
-	return common.WriteCookie(c, common.SonrAddress, address)
-}
-
-// SetVaultAuthorization sets the UCAN CID of the vault
-func SetVaultAuthorization(c echo.Context, ucanCID string) error {
-	common.HeaderWrite(c, common.Authorization, formatAuth(ucanCID))
-	return nil
-}
-
-// ╭───────────────────────────────────────────────────────────╮
-// │                       Initialization                      │
-// ╰───────────────────────────────────────────────────────────╯
-
-func loadOrGenKsuid(c echo.Context) error {
-	var (
-		sessionID string
-		err       error
-	)
-
-	// Setup genKsuid function
-	genKsuid := func() string {
-		return ksuid.New().String()
-	}
-
-	// Attempt to read the session ID from the "session" cookie
-	if ok := common.CookieExists(c, common.SessionID); !ok {
-		sessionID = genKsuid()
-	} else {
-		sessionID, err = common.ReadCookie(c, common.SessionID)
-		if err != nil {
-			sessionID = genKsuid()
-		}
-	}
-	common.WriteCookie(c, common.SessionID, sessionID)
-	return nil
-}
-
-// ╭───────────────────────────────────────────────────────────╮
-// │                       Extraction                          │
-// ╰───────────────────────────────────────────────────────────╯
-
-func extractPeerInfo(c echo.Context) (string, string) {
-	var chal protocol.URLEncodedBase64
-	id, _ := common.ReadCookie(c, common.SessionID)
-	chalRaw, _ := common.ReadCookieBytes(c, common.SessionChallenge)
-	chal.UnmarshalJSON(chalRaw)
-
-	return id, common.Base64Encode(chal)
-}
-
-func extractBrowserInfo(c echo.Context) (string, string) {
-	secCHUA := common.HeaderRead(c, common.UserAgent)
-
-	// If common.is empty, return empty BrowserInfo
-	if secCHUA == "" {
-		return "N/A", "-1"
-	}
-
-	// Split the common.into individual browser entries
-	var (
-		name string
-		ver  string
-	)
-	entries := strings.Split(strings.TrimSpace(secCHUA), ",")
-	for _, entry := range entries {
-		// Remove leading/trailing spaces and quotes
-		entry = strings.TrimSpace(entry)
-
-		// Use regex to extract the browser name and version
-		re := regexp.MustCompile(`"([^"]+)";v="([^"]+)"`)
-		matches := re.FindStringSubmatch(entry)
-
-		if len(matches) == 3 {
-			browserName := matches[1]
-			version := matches[2]
-
-			// Skip "Not A;Brand"
-			if !validBrowser(browserName) {
-				continue
-			}
-
-			// Store the first valid browser info as fallback
-			name = browserName
-			ver = version
-		}
-	}
-	return name, ver
-}
-
-func validBrowser(name string) bool {
-	return name != common.BrowserNameUnknown.String() && name != common.BrowserNameChromium.String()
-}
-
-// ╭───────────────────────────────────────────────────────────╮
-// │                        Authentication                     │
-// ╰───────────────────────────────────────────────────────────╯
-
-func buildUserEntity(userID string) protocol.UserEntity {
-	return protocol.UserEntity{
-		ID: userID,
-	}
-}
-
-// returns the base options for registering a new user without challenge or user entity.
-func baseRegisterOptions() *protocol.PublicKeyCredentialCreationOptions {
-	return &protocol.PublicKeyCredentialCreationOptions{
-		Timeout:     kWebAuthnTimeout,
-		Attestation: protocol.PreferDirectAttestation,
-		AuthenticatorSelection: protocol.AuthenticatorSelection{
-			AuthenticatorAttachment: "platform",
-			ResidentKey:             protocol.ResidentKeyRequirementPreferred,
-			UserVerification:        "preferred",
-		},
-		Parameters: []protocol.CredentialParameter{
-			{
-				Type:      "public-key",
-				Algorithm: webauthncose.AlgES256,
-			},
-			{
-				Type:      "public-key",
-				Algorithm: webauthncose.AlgES256K,
-			},
-			{
-				Type:      "public-key",
-				Algorithm: webauthncose.AlgEdDSA,
-			},
-		},
-	}
-}
-
-func formatAuth(ucanCID string) string {
-	return "Bearer " + ucanCID
-}

internal/vault/context/middleware.go

@@ -1,90 +0,0 @@
-package context
-
-import (
-	"encoding/json"
-	"net/http"
-
-	"github.com/labstack/echo/v4"
-	config "github.com/onsonr/sonr/pkg/config/motr"
-
-	"github.com/onsonr/sonr/pkg/common"
-)
-
-type SessionCtx interface {
-	ID() string
-	BrowserName() string
-	BrowserVersion() string
-}
-
-type contextKey string
-
-// Context keys
-const (
-	DataContextKey contextKey = "http_session_data"
-)
-
-// Get returns the session.Context from the echo context.
-func Get(c echo.Context) (SessionCtx, error) {
-	ctx, ok := c.(*HTTPContext)
-	if !ok {
-		return nil, echo.NewHTTPError(http.StatusInternalServerError, "Session Context not found")
-	}
-	return ctx, nil
-}
-
-// WebNodeMiddleware establishes a Session Cookie.
-func Middleware(config *config.Config) echo.MiddlewareFunc {
-	return func(next echo.HandlerFunc) echo.HandlerFunc {
-		return func(c echo.Context) error {
-			err := injectConfig(c, config)
-			if err != nil {
-				return err
-			}
-			cc := injectSession(c, common.RoleMotr)
-			return next(cc)
-		}
-	}
-}
-
-func injectConfig(c echo.Context, config *config.Config) error {
-	common.HeaderWrite(c, common.SonrAPIURL, config.SonrApiUrl)
-	common.HeaderWrite(c, common.SonrRPCURL, config.SonrRpcUrl)
-
-	common.WriteCookie(c, common.SonrAddress, config.MotrAddress)
-	schemaBz, err := json.Marshal(config.VaultSchema)
-	if err != nil {
-		return err
-	}
-	common.WriteCookieBytes(c, common.VaultSchema, schemaBz)
-	return nil
-}
-
-// injectSession returns the session injectSession from the cookies.
-func injectSession(c echo.Context, role common.PeerRole) *HTTPContext {
-	if c == nil {
-		return initHTTPContext(nil)
-	}
-
-	common.WriteCookie(c, common.SessionRole, role.String())
-
-	// Continue even if there are errors, just ensure we have valid session data
-	if err := loadOrGenKsuid(c); err != nil {
-		// Log error but continue
-	}
-	return initHTTPContext(c)
-}
-
-// HasAuthorization checks if the request has an authorization header
-func HasAuthorization(c echo.Context) bool {
-	return common.HeaderExists(c, common.Authorization)
-}
-
-// HasUserHandle checks if the request has a user handle cookie
-func HasUserHandle(c echo.Context) bool {
-	return common.CookieExists(c, common.UserHandle)
-}
-
-// HasVaultAddress checks if the request has a vault address cookie
-func HasVaultAddress(c echo.Context) bool {
-	return common.CookieExists(c, common.SonrAddress)
-}

internal/vault/context/session.go

@@ -1,51 +0,0 @@
-package context
-
-import (
-	"github.com/labstack/echo/v4"
-
-	"github.com/onsonr/sonr/pkg/common"
-)
-
-// HTTPContext is the context for HTTP endpoints.
-type HTTPContext struct {
-	echo.Context
-	role common.PeerRole
-	id   string
-	chal string
-	bn   string
-	bv   string
-}
-
-// initHTTPContext loads the headers from the request.
-func initHTTPContext(c echo.Context) *HTTPContext {
-	if c == nil {
-		return &HTTPContext{}
-	}
-
-	id, chal := extractPeerInfo(c)
-	bn, bv := extractBrowserInfo(c)
-
-	cc := &HTTPContext{
-		Context: c,
-		role:    common.PeerRole(common.ReadCookieUnsafe(c, common.SessionRole)),
-		id:      id,
-		chal:    chal,
-		bn:      bn,
-		bv:      bv,
-	}
-
-	// Set the session data in both contexts
-	return cc
-}
-
-func (s *HTTPContext) ID() string {
-	return s.id
-}
-
-func (s *HTTPContext) BrowserName() string {
-	return s.bn
-}
-
-func (s *HTTPContext) BrowserVersion() string {
-	return s.bv
-}

internal/vault/handlers/auth.go

@@ -1,7 +0,0 @@
-package handlers
-
-import "github.com/labstack/echo/v4"
-
-func HandleConnect(c echo.Context) error {
-	return nil
-}

internal/vault/handlers/authz.go

@@ -1,23 +0,0 @@
-package handlers
-
-import (
-	"github.com/labstack/echo/v4"
-)
-
-func GrantAuthorization(e echo.Context) error {
-	// Implement authorization endpoint using passkey authentication
-	// Store session data in cache
-	return nil
-}
-
-func GetJWKS(e echo.Context) error {
-	// Implement token endpoint
-	// Use cached session data for validation
-	return nil
-}
-
-func GetToken(e echo.Context) error {
-	// Implement token endpoint
-	// Use cached session data for validation
-	return nil
-}

internal/vault/handlers/feeds.go

@@ -1,11 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-
-	"github.com/labstack/echo/v4"
-)
-
-func RenderFeeds(c echo.Context) error {
-	return c.Render(http.StatusOK, "index.templ", nil)
-}

internal/vault/handlers/index.go

@@ -1,40 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-
-	"github.com/labstack/echo/v4"
-	"github.com/onsonr/sonr/internal/vault/context"
-)
-
-func RenderIndex(c echo.Context) error {
-	// TODO: Create views
-	if isReturning(c) {
-		// return response.TemplEcho(c, index.InitialView())
-	}
-	// TODO: Add authorization check
-	if isExpired(c) {
-		// return response.TemplEcho(c, index.ReturningView())
-	}
-	return c.Render(http.StatusOK, "index.templ", nil)
-}
-
-// ╭─────────────────────────────────────────────────────────╮
-// │                    Utility Functions                    │
-// ╰─────────────────────────────────────────────────────────╯
-
-// Expired users have either a user handle or vault address
-func isExpired(c echo.Context) bool {
-	noAuth := !context.HasAuthorization(c)
-	hasUserHandle := context.HasUserHandle(c)
-	hasVaultAddress := context.HasVaultAddress(c)
-	return noAuth && hasUserHandle || noAuth && hasVaultAddress
-}
-
-// Returning users have a valid authorization, and either a user handle or vault address
-func isReturning(c echo.Context) bool {
-	hasAuth := context.HasAuthorization(c)
-	hasUserHandle := context.HasUserHandle(c)
-	hasVaultAddress := context.HasVaultAddress(c)
-	return hasAuth && (hasUserHandle || hasVaultAddress)
-}

internal/vault/handlers/profile.go

@@ -1 +0,0 @@
-package handlers

internal/vault/handlers/search.go

@@ -1 +0,0 @@
-package handlers

internal/vault/handlers/wallet.go

@@ -1,93 +0,0 @@
-package handlers
-
-//
-// // Constants for supported payment methods
-// const (
-// 	MethodCard       = "basic-card"
-// 	MethodGooglePay  = "https://google.com/pay"
-// 	MethodApplePay   = "https://apple.com/apple-pay"
-// 	MethodSonrWallet = "https://sonr.id/wallet"
-// )
-//
-// // InitiatePayment starts the payment request flow
-// func InitiatePayment(c echo.Context, request PaymentRequest) error {
-// 	return StartPayment(request).Render(c.Request().Context(), c.Response().Writer)
-// }
-//
-// // Helper functions to create payment requests
-// func NewBasicCardPayment(amount float64, currency string, label string) PaymentRequest {
-// 	return PaymentRequest{
-// 		MethodData: []PaymentMethodData{
-// 			{
-// 				SupportedMethods: MethodCard,
-// 				Data: map[string]any{
-// 					"supportedNetworks": []string{"visa", "mastercard"},
-// 					"supportedTypes":    []string{"credit", "debit"},
-// 				},
-// 			},
-// 		},
-// 		Details: PaymentDetails{
-// 			Total: PaymentItem{
-// 				Label: label,
-// 				Amount: Money{
-// 					Currency: currency,
-// 					Value:    formatAmount(amount),
-// 				},
-// 			},
-// 		},
-// 		Options: PaymentOptions{
-// 			RequestPayerName:  true,
-// 			RequestPayerEmail: true,
-// 		},
-// 	}
-// }
-//
-// // Example usage:
-// func PaymentHandler(c echo.Context) error {
-// 	request := NewBasicCardPayment(99.99, "USD", "Product Purchase")
-//
-// 	// Add display items
-// 	request.Details.DisplayItems = []PaymentItem{
-// 		{
-// 			Label: "Product Price",
-// 			Amount: Money{
-// 				Currency: "USD",
-// 				Value:    "89.99",
-// 			},
-// 		},
-// 		{
-// 			Label: "Tax",
-// 			Amount: Money{
-// 				Currency: "USD",
-// 				Value:    "10.00",
-// 			},
-// 		},
-// 	}
-//
-// 	// Add shipping options
-// 	request.Details.ShippingOptions = []ShippingOption{
-// 		{
-// 			ID:    "standard",
-// 			Label: "Standard Shipping",
-// 			Amount: Money{
-// 				Currency: "USD",
-// 				Value:    "0.00",
-// 			},
-// 			Selected: true,
-// 		},
-// 		{
-// 			ID:    "express",
-// 			Label: "Express Shipping",
-// 			Amount: Money{
-// 				Currency: "USD",
-// 				Value:    "10.00",
-// 			},
-// 		},
-// 	}
-//
-// 	return InitiatePayment(c, request)
-// }
-//
-// func formatAmount(amount float64) string {
-// 	return fmt.Sprintf("%.2f", amount)
-// }

internal/vault/routes.go

@@ -1,17 +0,0 @@
-//go:build js && wasm
-// +build js,wasm
-
-// Package vault provides the routes for the Decentralized Web Node (...or Sonr Motr).
-package vault
-
-import (
-	"github.com/labstack/echo/v4"
-
-	"github.com/onsonr/sonr/internal/vault/context"
-	"github.com/onsonr/sonr/pkg/config/motr"
-)
-
-// RegisterRoutes registers the Decentralized Web Node API routes.
-func RegisterRoutes(e *echo.Echo, config *motr.Config) {
-	e.Use(context.Middleware(config))
-}