feature/1220 origin handle exists method (#1241)

* feat: add docs and CI workflow for publishing to onsonr.dev

* (refactor): Move hway,motr executables to their own repos

* feat: simplify devnet and testnet configurations

* refactor: update import path for didcrypto package

* docs(networks): Add README with project overview, architecture, and community links

* refactor: Move network configurations to deploy directory

* build: update golang version to 1.23

* refactor: move logger interface to appropriate package

* refactor: Move devnet configuration to networks/devnet

* chore: improve release process with date variable

* (chore): Move Crypto Library

* refactor: improve code structure and readability in DID module

* feat: integrate Trunk CI checks

* ci: optimize CI workflow by removing redundant build jobs

---------

Co-authored-by: Darp Alakun <i@prad.nu>

internal/accounts/protoaccount.go

@@ -0,0 +1,78 @@
+package accounts
+
+import (
+	"context"
+	"fmt"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/onsonr/sonr/internal/transaction"
+)
+
+// RegisterInitHandler registers an initialisation handler for a smart account that uses protobuf.
+func RegisterInitHandler[
+	Req any, ProtoReq ProtoMsgG[Req], Resp any, ProtoResp ProtoMsgG[Resp],
+](router *InitBuilder, handler func(ctx context.Context, req ProtoReq) (ProtoResp, error),
+) {
+	reqName := MessageName(ProtoReq(new(Req)))
+
+	router.handler = func(ctx context.Context, initRequest transaction.Msg) (initResponse transaction.Msg, err error) {
+		concrete, ok := initRequest.(ProtoReq)
+		if !ok {
+			return nil, fmt.Errorf("%w: wanted %s, got %T", errInvalidMessage, reqName, initRequest)
+		}
+		return handler(ctx, concrete)
+	}
+
+	router.schema = HandlerSchema{
+		RequestSchema:  *NewProtoMessageSchema[Req, ProtoReq](),
+		ResponseSchema: *NewProtoMessageSchema[Resp, ProtoResp](),
+	}
+}
+
+// RegisterExecuteHandler registers an execution handler for a smart account that uses protobuf.
+func RegisterExecuteHandler[
+	Req any, ProtoReq ProtoMsgG[Req], Resp any, ProtoResp ProtoMsgG[Resp],
+](router *ExecuteBuilder, handler func(ctx context.Context, req ProtoReq) (ProtoResp, error),
+) {
+	reqName := MessageName(ProtoReq(new(Req)))
+	// check if not registered already
+	if _, ok := router.handlers[reqName]; ok {
+		router.err = fmt.Errorf("handler already registered for message %s", reqName)
+		return
+	}
+
+	router.handlers[reqName] = func(ctx context.Context, executeRequest transaction.Msg) (executeResponse transaction.Msg, err error) {
+		concrete, ok := executeRequest.(ProtoReq)
+		if !ok {
+			return nil, fmt.Errorf("%w: wanted %s, got %T", errInvalidMessage, reqName, executeRequest)
+		}
+		return handler(ctx, concrete)
+	}
+
+	router.handlersSchema[reqName] = HandlerSchema{
+		RequestSchema:  *NewProtoMessageSchema[Req, ProtoReq](),
+		ResponseSchema: *NewProtoMessageSchema[Resp, ProtoResp](),
+	}
+}
+
+// RegisterQueryHandler registers a query handler for a smart account that uses protobuf.
+func RegisterQueryHandler[
+	Req any, ProtoReq ProtoMsgG[Req], Resp any, ProtoResp ProtoMsgG[Resp],
+](router *QueryBuilder, handler func(ctx context.Context, req ProtoReq) (ProtoResp, error),
+) {
+	RegisterExecuteHandler(router.er, handler)
+}
+
+func NewProtoMessageSchema[T any, PT ProtoMsgG[T]]() *MessageSchema {
+	msg := PT(new(T))
+	if _, ok := (interface{}(msg)).(proto.Message); ok {
+		panic("protov2 messages are not supported")
+	}
+	return &MessageSchema{
+		Name: MessageName(msg),
+		New: func() transaction.Msg {
+			return PT(new(T))
+		},
+	}
+}