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

cmd/hway/cmds.go

@@ -6,6 +6,8 @@ import (
 	"net/http"
 	"os"
 
+	"github.com/onsonr/sonr/pkg/common"
+	"github.com/onsonr/sonr/pkg/gateway"
 	"github.com/spf13/cobra"
 )
 
@@ -18,11 +20,10 @@ var (
 	sonrGrpcURL    string // Sonr gRPC URL (default localhost:9090)
 	sonrRPCURL     string // Sonr RPC URL (default localhost:26657)
 
-	sqliteFile string // SQLite database file (default hway.db)
-	psqlHost   string // PostgresSQL Host Flag
-	psqlUser   string // PostgresSQL User Flag
-	psqlPass   string // PostgresSQL Password Flag
-	psqlDB     string // PostgresSQL Database Flag
+	psqlHost string // PostgresSQL Host Flag
+	psqlUser string // PostgresSQL User Flag
+	psqlPass string // PostgresSQL Password Flag
+	psqlDB   string // PostgresSQL Database Flag
 )
 
 func rootCmd() *cobra.Command {
@@ -34,11 +35,11 @@ func rootCmd() *cobra.Command {
 			if err != nil {
 				panic(err)
 			}
-			db, ipc, err := initDeps(env)
+			ipc, err := common.NewIPFS()
 			if err != nil {
 				panic(err)
 			}
-			e, err := setupServer(env, db, ipc)
+			e, err := gateway.New(env, ipc)
 			if err != nil {
 				panic(err)
 			}
@@ -55,7 +56,6 @@ func rootCmd() *cobra.Command {
 	cmd.Flags().StringVar(&sonrAPIURL, "sonr-api-url", "localhost:1317", "Sonr API URL")
 	cmd.Flags().StringVar(&sonrGrpcURL, "sonr-grpc-url", "localhost:9090", "Sonr gRPC URL")
 	cmd.Flags().StringVar(&sonrRPCURL, "sonr-rpc-url", "localhost:26657", "Sonr RPC URL")
-	cmd.Flags().StringVar(&sqliteFile, "sqlite-file", "hway.db", "File to store sqlite database")
 	cmd.Flags().StringVar(&psqlHost, "psql-host", "", "PostgresSQL Host")
 	cmd.Flags().StringVar(&psqlUser, "psql-user", "", "PostgresSQL User")
 	cmd.Flags().StringVar(&psqlPass, "psql-pass", "", "PostgresSQL Password")

cmd/hway/main.go

@@ -5,15 +5,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/labstack/echo-contrib/echoprometheus"
-	"github.com/labstack/echo/v4"
-	"github.com/labstack/echo/v4/middleware"
-	"github.com/onsonr/sonr/crypto/ucan"
-	"github.com/onsonr/sonr/internal/gateway"
-	config "github.com/onsonr/sonr/pkg/config/hway"
-	"github.com/onsonr/sonr/pkg/didauth/producer"
-	"github.com/onsonr/sonr/pkg/ipfsapi"
-	"gorm.io/gorm"
+	config "github.com/onsonr/sonr/internal/config/hway"
 )
 
 // main is the entry point for the application
@@ -26,20 +18,6 @@ func main() {
 	os.Exit(0)
 }
 
-func initDeps(env config.Hway) (*gorm.DB, ipfsapi.Client, error) {
-	db, err := gateway.NewDB(env)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	ipc, err := ipfsapi.NewClient()
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return db, ipc, nil
-}
-
 func loadEnvImplFromArgs(args []string) (config.Hway, error) {
 	cmd := rootCmd()
 	if err := cmd.ParseFlags(args); err != nil {
@@ -48,7 +26,6 @@ func loadEnvImplFromArgs(args []string) (config.Hway, error) {
 
 	env := &config.HwayImpl{
 		ServePort:      servePort,
-		SqliteFile:     sqliteFile,
 		ChainId:        chainID,
 		IpfsGatewayUrl: ipfsGatewayURL,
 		SonrApiUrl:     sonrAPIURL,
@@ -58,15 +35,3 @@ func loadEnvImplFromArgs(args []string) (config.Hway, error) {
 	}
 	return env, nil
 }
-
-// setupServer sets up the server
-func setupServer(env config.Hway, db *gorm.DB, ipc ipfsapi.Client) (*echo.Echo, error) {
-	e := echo.New()
-	e.Use(echoprometheus.NewMiddleware("hway"))
-	e.IPExtractor = echo.ExtractIPDirect()
-	e.Use(middleware.Logger())
-	e.Use(middleware.Recover())
-	e.Use(producer.Middleware(ipc, ucan.ServicePermissions))
-	gateway.RegisterRoutes(e, env, db)
-	return e, nil
-}

cmd/motr/main.go

@@ -8,10 +8,9 @@ import (
 	"syscall/js"
 
 	"github.com/labstack/echo/v4"
-	"github.com/onsonr/sonr/internal/vault"
-	"github.com/onsonr/sonr/pkg/common/wasm"
-	"github.com/onsonr/sonr/pkg/config/motr"
-	// "github.com/onsonr/sonr/pkg/didauth/controller"
+	"github.com/onsonr/sonr/pkg/vault/routes"
+	"github.com/onsonr/sonr/cmd/motr/wasm"
+	"github.com/onsonr/sonr/internal/config/motr"
 )
 
 var (
@@ -28,7 +27,7 @@ func simulateTx(this js.Value, args []js.Value) interface{} {
 	return nil
 }
 
-func processConfig(this js.Value, args []js.Value) interface{} {
+func syncData(this js.Value, args []js.Value) interface{} {
 	if len(args) < 1 {
 		return nil
 	}
@@ -45,7 +44,7 @@ func main() {
 	// Load dwn config
 	js.Global().Set("broadcastTx", js.FuncOf(broadcastTx))
 	js.Global().Set("simulateTx", js.FuncOf(simulateTx))
-	js.Global().Set("processConfig", js.FuncOf(processConfig))
+	js.Global().Set("syncData", js.FuncOf(syncData))
 
 	e := echo.New()
 	e.Use(wasm.ContextMiddleware)

cmd/motr/wasm/fetch.go

@@ -0,0 +1,211 @@
+//go:build js && wasm
+// +build js,wasm
+
+package wasm
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"syscall/js"
+)
+
+var (
+	// Global buffer pool to reduce allocations
+	bufferPool = sync.Pool{
+		New: func() interface{} {
+			return new(bytes.Buffer)
+		},
+	}
+
+	// Cached JS globals
+	jsGlobal     = js.Global()
+	jsUint8Array = jsGlobal.Get("Uint8Array")
+	jsResponse   = jsGlobal.Get("Response")
+	jsPromise    = jsGlobal.Get("Promise")
+	jsWasmHTTP   = jsGlobal.Get("wasmhttp")
+)
+
+// ServeFetch serves HTTP requests with optimized handler management
+func ServeFetch(handler http.Handler) func() {
+	h := handler
+	if h == nil {
+		h = http.DefaultServeMux
+	}
+
+	// Optimize prefix handling
+	prefix := strings.TrimRight(jsWasmHTTP.Get("path").String(), "/")
+	if prefix != "" {
+		mux := http.NewServeMux()
+		mux.Handle(prefix+"/", http.StripPrefix(prefix, h))
+		h = mux
+	}
+
+	// Create request handler function
+	cb := js.FuncOf(func(_ js.Value, args []js.Value) interface{} {
+		promise, resolve, reject := newPromiseOptimized()
+
+		go handleRequest(h, args[1], resolve, reject)
+
+		return promise
+	})
+
+	jsWasmHTTP.Call("setHandler", cb)
+	return cb.Release
+}
+
+// handleRequest processes the request with panic recovery
+func handleRequest(h http.Handler, jsReq js.Value, resolve, reject func(interface{})) {
+	defer func() {
+		if r := recover(); r != nil {
+			var errMsg string
+			if err, ok := r.(error); ok {
+				errMsg = fmt.Sprintf("wasmhttp: panic: %+v", err)
+			} else {
+				errMsg = fmt.Sprintf("wasmhttp: panic: %v", r)
+			}
+			reject(errMsg)
+		}
+	}()
+
+	recorder := newResponseRecorder()
+	h.ServeHTTP(recorder, buildRequest(jsReq))
+	resolve(recorder.jsResponse())
+}
+
+// buildRequest creates an http.Request from JS Request
+func buildRequest(jsReq js.Value) *http.Request {
+	// Get request body
+	arrayBuffer, err := awaitPromiseOptimized(jsReq.Call("arrayBuffer"))
+	if err != nil {
+		panic(err)
+	}
+
+	// Create body buffer
+	jsBody := jsUint8Array.New(arrayBuffer)
+	bodyLen := jsBody.Get("length").Int()
+	body := make([]byte, bodyLen)
+	js.CopyBytesToGo(body, jsBody)
+
+	// Create request
+	req := httptest.NewRequest(
+		jsReq.Get("method").String(),
+		jsReq.Get("url").String(),
+		bytes.NewReader(body),
+	)
+
+	// Set headers efficiently
+	headers := jsReq.Get("headers")
+	headersIt := headers.Call("entries")
+	for {
+		entry := headersIt.Call("next")
+		if entry.Get("done").Bool() {
+			break
+		}
+		pair := entry.Get("value")
+		req.Header.Set(pair.Index(0).String(), pair.Index(1).String())
+	}
+
+	return req
+}
+
+// ResponseRecorder with optimized buffer handling
+type ResponseRecorder struct {
+	*httptest.ResponseRecorder
+	buffer *bytes.Buffer
+}
+
+func newResponseRecorder() *ResponseRecorder {
+	return &ResponseRecorder{
+		ResponseRecorder: httptest.NewRecorder(),
+		buffer:           bufferPool.Get().(*bytes.Buffer),
+	}
+}
+
+// jsResponse creates a JS Response with optimized memory usage
+func (rr *ResponseRecorder) jsResponse() js.Value {
+	defer func() {
+		rr.buffer.Reset()
+		bufferPool.Put(rr.buffer)
+	}()
+
+	res := rr.Result()
+	defer res.Body.Close()
+
+	// Prepare response body
+	body := js.Undefined()
+	if res.ContentLength != 0 {
+		if _, err := io.Copy(rr.buffer, res.Body); err != nil {
+			panic(err)
+		}
+		bodyBytes := rr.buffer.Bytes()
+		body = jsUint8Array.New(len(bodyBytes))
+		js.CopyBytesToJS(body, bodyBytes)
+	}
+
+	// Prepare response init object
+	init := make(map[string]interface{}, 3)
+	if res.StatusCode != 0 {
+		init["status"] = res.StatusCode
+	}
+
+	if len(res.Header) > 0 {
+		headers := make(map[string]interface{}, len(res.Header))
+		for k, v := range res.Header {
+			if len(v) > 0 {
+				headers[k] = v[0]
+			}
+		}
+		init["headers"] = headers
+	}
+
+	return jsResponse.New(body, init)
+}
+
+// newPromiseOptimized creates a new JavaScript Promise with optimized callback handling
+func newPromiseOptimized() (js.Value, func(interface{}), func(interface{})) {
+	var (
+		resolve     func(interface{})
+		reject      func(interface{})
+		promiseFunc = js.FuncOf(func(_ js.Value, args []js.Value) interface{} {
+			resolve = func(v interface{}) { args[0].Invoke(v) }
+			reject = func(v interface{}) { args[1].Invoke(v) }
+			return js.Undefined()
+		})
+	)
+	defer promiseFunc.Release()
+
+	return jsPromise.New(promiseFunc), resolve, reject
+}
+
+// awaitPromiseOptimized waits for Promise resolution with optimized channel handling
+func awaitPromiseOptimized(promise js.Value) (js.Value, error) {
+	done := make(chan struct{})
+	var (
+		result js.Value
+		err    error
+	)
+
+	thenFunc := js.FuncOf(func(_ js.Value, args []js.Value) interface{} {
+		result = args[0]
+		close(done)
+		return nil
+	})
+	defer thenFunc.Release()
+
+	catchFunc := js.FuncOf(func(_ js.Value, args []js.Value) interface{} {
+		err = js.Error{Value: args[0]}
+		close(done)
+		return nil
+	})
+	defer catchFunc.Release()
+
+	promise.Call("then", thenFunc).Call("catch", catchFunc)
+	<-done
+
+	return result, err
+}

cmd/motr/wasm/wasm.go

@@ -0,0 +1,34 @@
+//go:build js && wasm
+// +build js,wasm
+
+package wasm
+
+import (
+	"encoding/base64"
+	"encoding/json"
+
+	"github.com/labstack/echo/v4"
+)
+
+func ContextMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(c echo.Context) error {
+		// Extract WASM context from headers
+		if wasmCtx := c.Request().Header.Get("X-Wasm-Context"); wasmCtx != "" {
+			if ctx, err := DecodeWasmContext(wasmCtx); err == nil {
+				c.Set("wasm_context", ctx)
+			}
+		}
+		return next(c)
+	}
+}
+
+// decodeWasmContext decodes the WASM context from a base64 encoded string
+func DecodeWasmContext(ctx string) (map[string]any, error) {
+	decoded, err := base64.StdEncoding.DecodeString(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var ctxData map[string]any
+	err = json.Unmarshal(decoded, &ctxData)
+	return ctxData, err
+}