mediator/unpack.go

 package mediator
 
 import (
-	"gaiax/didcommconnector/didcomm"
-	"gaiax/didcommconnector/mediator/callback"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator/callback"
 )
 
 func (m *Mediator) UnpackMessage(body string) (didcomm.Message, error) {

peerdid/peerdid.go

-package peerdid
-
-import (
-	"crypto/ecdh"
-	"crypto/ed25519"
-	"crypto/rand"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"gaiax/didcommconnector/didcomm"
-	"gaiax/didcommconnector/mediator"
-	"strings"
-
-	"github.com/multiformats/go-multibase"
-)
-
-// TODO: slogger
-
-func NumAlgo2(services []didcomm.Service, mediator mediator.Mediator) (peerDid string) {
-
-	encPub, encPriv, err := generateX25519Base58BTC()
-	if err != nil {
-		fmt.Println("Error generating X25518 keypair:", err)
-		return
-	}
-	encSecret := *createSecretFromKeyPair(encPub, encPriv, didcomm.SecretTypeX25519KeyAgreementKey2020)
-
-	signPub, singPriv, err := generateEd25519Base58BTC()
-	if err != nil {
-		fmt.Println("Error generating Ed25519 keypair:", err)
-		return
-	}
-	signSecret := *createSecretFromKeyPair(signPub, singPriv, didcomm.SecretTypeEd25519VerificationKey2020)
-	serviceB64URL := encodeServicesToB64URL(services)
-	peerDid = fmt.Sprintf("did:peer:2.E%s.V%s%s", encPub, signPub, serviceB64URL)
-
-	didResolver := mediator.DidResolver
-	didDoc, err := didResolver.ResolveDid(peerDid)
-	if err != nil {
-		fmt.Println("Error resolving peer DID:", err)
-		return
-	}
-	secretResolver := mediator.SecretsResolver
-	// store encryption keys in secret resolver
-	for _, key := range didDoc.VerificationMethod {
-		s := strings.Split(key.Id, "#")
-		identifier := s[len(s)-1]
-		for _, secret := range []didcomm.Secret{encSecret, signSecret} {
-
-			if identifier == secret.Id {
-				secret.Id = key.Id
-				secretResolver.StoreSecret(secret)
-			}
-		}
-	}
-
-	return peerDid
-}
-
-// Generate Encryption Keypair
-func generateX25519Base58BTC() (public string, private string, err error) {
-	randEncryption := rand.Reader
-
-	privPrefix := []byte{0x82, 0x26}
-	privateEncryption, err := ecdh.X25519().GenerateKey(randEncryption)
-	if err != nil {
-		return "", "", err
-	}
-	// append prefix
-	privWPrefix := append(privPrefix, privateEncryption.Bytes()...)
-
-	private, err = multibase.Encode(multibase.Base58BTC, privWPrefix)
-	if err != nil {
-		return "", "", err
-	}
-
-	pubPrefix := []byte{0xEC, 0x01}
-	publicEncryption := privateEncryption.PublicKey()
-	pubWPrefix := append(pubPrefix, publicEncryption.Bytes()...)
-	public, err = multibase.Encode(multibase.Base58BTC, pubWPrefix)
-	if err != nil {
-		return "", "", err
-	}
-
-	return public, private, nil
-}
-
-// Generate Signing Keypair
-func generateEd25519Base58BTC() (public string, private string, err error) {
-	randEncryption := rand.Reader
-	publicRaw, privateRaw, err := ed25519.GenerateKey(randEncryption)
-	if err != nil {
-		return "", "", err
-	}
-
-	privPrefix := []byte{0x80, 0x26}
-	privateRaw = append(privPrefix, privateRaw...)
-	private, err = multibase.Encode(multibase.Base58BTC, privateRaw)
-	if err != nil {
-		return "", "", err
-	}
-
-	pubPrefix := []byte{0xED, 0x01}
-	publicRaw = append(pubPrefix, publicRaw...)
-	public, err = multibase.Encode(multibase.Base58BTC, publicRaw)
-	if err != nil {
-		return "", "", err
-	}
-
-	return public, private, nil
-}
-
-type serviceEncoded struct {
-	T string `json:"t"`
-	S struct {
-		URI string   `json:"uri"`
-		A   []string `json:"a"`
-		R   []string `json:"r"`
-	} `json:"s"`
-}
-
-func encodeServiceToB64URL(service didcomm.Service) (multibaseService string) {
-	serviceKind := service.ServiceEndpoint.(didcomm.ServiceKindDidCommMessaging)
-	shortServiceStruct := serviceEncoded{
-		T: "dm",
-		S: struct {
-			URI string   "json:\"uri\""
-			A   []string "json:\"a\""
-			R   []string "json:\"r\""
-		}{
-			URI: serviceKind.Value.Uri,
-			A:   *serviceKind.Value.Accept,
-			R:   serviceKind.Value.RoutingKeys,
-		},
-	}
-
-	json, err := json.Marshal(shortServiceStruct)
-	if err != nil {
-		fmt.Println("Error marshalling service:", err)
-		return
-	}
-	m := base64.RawURLEncoding.EncodeToString(json)
-
-	// https://identity.foundation/peer-did-method-spec/#generating-a-didpeer2
-	// peer DID method requires the = character to be removed from the base64url encoded string
-	m = strings.ReplaceAll(m, "=", "")
-	return m
-}
-
-func encodeServicesToB64URL(services []didcomm.Service) (service string) {
-	serviceString := ""
-	for _, s := range services {
-		serviceString += fmt.Sprintf(".S%s", encodeServiceToB64URL(s))
-	}
-	return serviceString
-}
-
-func createSecretFromKeyPair(public string, private string, t didcomm.SecretType) *didcomm.Secret {
-	// first character is the multibase identifier
-	// expected to be z for base58btc
-	id := public[1:]
-	secret := didcomm.Secret{
-		Id:   id,
-		Type: t,
-		SecretMaterial: didcomm.SecretMaterialMultibase{
-			PrivateKeyMultibase: private,
-		},
-	}
-	return &secret
-}
-
-func resolveSecretTypes(t string) didcomm.SecretType {
-	switch t {
-	case "X25519KeyAgreementKey2019":
-		return didcomm.SecretTypeX25519KeyAgreementKey2019
-	case "Ed25519VerificationKey2018":
-		return didcomm.SecretTypeEd25519VerificationKey2018
-	case "EcdsaSecp256k1VerificationKey2019":
-		return didcomm.SecretTypeEcdsaSecp256k1VerificationKey2019
-	case "X25519KeyAgreementKey2020":
-		return didcomm.SecretTypeX25519KeyAgreementKey2020
-	case "Ed25519VerificationKey2020":
-		return didcomm.SecretTypeEd25519VerificationKey2020
-	default:
-		return didcomm.SecretTypeOther
-	}
-}

pkg/constants/constants.go

+package constants
+
+const PIURI_COORDINATE_MEDIATION = "https://didcomm.org/coordinate-mediation/"
+const PIURI_COORDINATE_MEDIATION_REQUEST = "https://didcomm.org/coordinate-mediation/3.0/mediate-request"
+const PIURI_COORDINATE_MEDIATION_UPDATE = "https://didcomm.org/coordinate-mediation/3.0/recipient-update"
+const PIURI_COORDINATE_MEDIATION_QUERY = "https://didcomm.org/coordinate-mediation/3.0/recipient-query"
+const PIURI_COORDINATE_MEDIATION_RESPOSE_DENY = "https://didcomm.org/coordinate-mediation/3.0/mediate-deny"
+const PIURI_COORDINATE_MEDIATION_RESPOSE_GRANT = "https://didcomm.org/coordinate-mediation/3.0/mediate-grant"

pkg/messaging/connectorMessage.go

+package messaging
+
+import "encoding/json"
+
+type ConnectorMessage struct {
+	Did     string          `json:"did"`
+	Payload json.RawMessage `json:"payload"`
+}
+
+type InvitationNotify struct {
+	InvitationId string `json:"invitationId"`
+	Did          string `json:"did"`
+}

protocol/cloudEvent.go

 package protocol
 
 import (
+	"bytes"
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"gaiax/didcommconnector/internal/config"
-	"gaiax/didcommconnector/mediator"
-	"gaiax/didcommconnector/mediator/database"
 	"net/url"
 	"sync"
+	"text/template"
 
 	"github.com/cloudevents/sdk-go/v2/event"
+	"github.com/google/uuid"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/config"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator/database"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/pkg/messaging"
 	"gitlab.eclipse.org/eclipse/xfsc/libraries/messaging/cloudeventprovider"
 )
 
-type outgoingNatsMessage struct {
-	Properties map[string]string `json:"properties"`
-	Message    []byte            `json:"message"`
-}
-
-type incomingNatsMessage struct {
-	Properties map[string]string `json:"properties"`
-	Message    []byte            `json:"message"`
-}
-
-func SendMessage(message string, mediatee *database.Mediatee) error {
+func SendMessage(message map[string]interface{}, mediatee *database.Mediatee) error {
 
 	switch config.CurrentConfiguration.CloudForwarding.Protocol {
 	case config.HTTP:
-		return sendCloudEvent(message, mediatee)
+		return sendCloudEvent(message, mediatee, mediatee.Topic)
 	case config.NATS:
-		return sendCloudEvent(message, mediatee)
+		return sendCloudEvent(message, mediatee, mediatee.Topic)
 	case config.HYBRID:
 		// implement hybrid mode if cloud event provider supports it
 		return errors.New("hybrid mode not supported: message will not be sent")
@@ -41,15 +37,23 @@ func SendMessage(message string, mediatee *database.Mediatee) error {
 
 func ReceiveMessage(mediator *mediator.Mediator) {
 
+	config.Logger.Info("Start messaging", "context")
+
 	topic := config.CurrentConfiguration.CloudForwarding.Nats.Topic
 
-	client, err := cloudeventprovider.NewClient(cloudeventprovider.Sub, topic)
+	client, err := cloudeventprovider.New(cloudeventprovider.Config{
+		Protocol: cloudeventprovider.ProtocolTypeNats,
+		Settings: cloudeventprovider.NatsConfig{
+			Url:        config.CurrentConfiguration.CloudForwarding.Nats.Url,
+			QueueGroup: config.CurrentConfiguration.CloudForwarding.Nats.QueueGroup,
+		},
+	}, cloudeventprovider.Sub, topic)
 	if err != nil {
 		config.Logger.Error("unable to connect to cloud event provider", "msg", err)
 	}
 
 	defer client.Close()
-
+	routing := NewRouting(mediator)
 	// Use a WaitGroup to wait for a message to arrive
 	wg := sync.WaitGroup{}
 	wg.Add(1)
@@ -61,40 +65,48 @@ func ReceiveMessage(mediator *mediator.Mediator) {
 		config.Logger.Info("Received cloud event", "context", event.Context)
 		config.Logger.Info("Data", "context", string(event.DataEncoded))
 
-		var incomingMessage incomingNatsMessage
+		var incomingMessage json.RawMessage
 		err := json.Unmarshal(event.DataEncoded, &incomingMessage)
 		if err != nil {
 			config.Logger.Error("error while unmarshalling received nats message")
 			return
 		}
-		unpacked, err := mediator.UnpackMessage(string(incomingMessage.Message))
+
+		var content messaging.ConnectorMessage
+
+		err = json.Unmarshal(incomingMessage, &content)
+
 		if err != nil {
-			config.Logger.Error("error while unpacking received nats message")
+			config.Logger.Error("error while unmarshalling received nats message")
 			return
 		}
-		mediatee, err := mediator.Database.GetMediatee(*unpacked.From)
-		if err != nil {
-			config.Logger.Error("error getting mediatee", "err", err)
-			return
+
+		attachment := didcomm.Attachment{
+			Data: didcomm.AttachmentDataBase64{
+				Value: didcomm.Base64AttachmentData{
+					Base64: base64.StdEncoding.EncodeToString(incomingMessage),
+				},
+			},
 		}
-		packedMsg, err := HandleMessage(string(incomingMessage.Message), mediator)
+
+		var body = make(map[string]interface{})
+
+		body["next"] = content.Did
+
+		bodyJson, err := json.Marshal(body)
 		if err != nil {
-			config.Logger.Error("error while handling received nats message")
-			return
+			panic(err)
 		}
-		if packedMsg != "" {
-			if err != nil {
-				config.Logger.Error("error getting mediatee", "err", err)
-				return
-			}
-			// send message to cPCM (cloud)
-			err = SendMessage(packedMsg, mediatee)
-			if err != nil {
-				config.Logger.Error("unable to send message to cloud", "err", err)
-				return
-			}
+
+		message := didcomm.Message{
+			Id:          uuid.NewString(),
+			Type:        PIURI_ROUTING_FORWARD,
+			To:          &[]string{mediator.Did},
+			Attachments: &[]didcomm.Attachment{attachment},
+			Body:        string(bodyJson),
 		}
 
+		routing.handleForward(message, false)
 	})
 	if err != nil {
 		config.Logger.Error("Error in subscription of cloud event", "msg", err)
@@ -104,33 +116,45 @@ func ReceiveMessage(mediator *mediator.Mediator) {
 	wg.Wait()
 }
 
-func sendCloudEvent(message string, mediatee *database.Mediatee) (err error) {
-	topic := mediatee.Topic
+func sendCloudEvent(message any, mediatee *database.Mediatee, topic string) (err error) {
 	if topic == "" {
 		topic = "default-http"
 	}
-	client, err := cloudeventprovider.NewClient(cloudeventprovider.Pub, topic)
+	client, err := cloudeventprovider.New(cloudeventprovider.Config{
+		Protocol: cloudeventprovider.ProtocolTypeNats,
+		Settings: cloudeventprovider.NatsConfig{
+			Url:        config.CurrentConfiguration.CloudForwarding.Nats.Url,
+			QueueGroup: config.CurrentConfiguration.CloudForwarding.Nats.QueueGroup,
+		},
+	}, cloudeventprovider.Pub, topic)
 	if err != nil {
 		config.Logger.Error("Can not create cloudevent client", "msg", err)
 		return
 	}
 	defer client.Close()
 
-	sourceUrl, err := url.JoinPath(config.CurrentConfiguration.CloudForwarding.Http.Url)
+	sourceUrl, err := url.JoinPath(config.CurrentConfiguration.CloudForwarding.Nats.Url)
 
 	config.Logger.Info(fmt.Sprintf("message to send as cloud event: %s", message))
 
-	dataToSend := outgoingNatsMessage{
-		Properties: mediatee.Properties,
-		Message:    json.RawMessage(message),
-	}
+	mediatee.Properties["routingKey"] = mediatee.RoutingKey
+	mediatee.Properties["remoteDid"] = mediatee.RemoteDid
+
+	jsonData, err := json.Marshal(mediatee.Properties)
 
-	dataJson, err := json.Marshal(dataToSend)
 	if err != nil {
-		config.Logger.Error("failed to marshal data to json", "msg", err)
+		config.Logger.Error("cant marshal properties", "msg", err)
 		return
 	}
-	event, err := cloudeventprovider.NewEvent(sourceUrl, "application/json", dataJson)
+
+	tmpl, err := template.New("template").Parse(string(jsonData))
+	var result bytes.Buffer
+	err = tmpl.Execute(&result, message)
+	if err != nil {
+		panic(err)
+	}
+
+	event, err := cloudeventprovider.NewEvent(sourceUrl, mediatee.EventType, result.Bytes())
 	if err != nil {
 		config.Logger.Error("failed to create cloud event", "msg", err)
 		return

protocol/coordinateMediation.go

@@ -2,12 +2,14 @@ package protocol
 
 import (
 	"encoding/json"
-	"gaiax/didcommconnector/didcomm"
-	"gaiax/didcommconnector/internal/config"
-	"gaiax/didcommconnector/mediator"
 	"slices"
 
 	"github.com/google/uuid"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/config"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/pkg/constants"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/pkg/messaging"
 )
 
 // update model
@@ -22,25 +24,20 @@ type CoordinateMediation struct {
 	mediator *mediator.Mediator
 }
 
-const PIURI_COORDINATE_MEDIATION = "https://didcomm.org/coordinate-mediation/"
-const PIURI_COORDINATE_MEDIATION_REQUEST = "https://didcomm.org/coordinate-mediation/3.0/mediate-request"
-const PIURI_COORDINATE_MEDIATION_UPDATE = "https://didcomm.org/coordinate-mediation/3.0/recipient-update"
-const PIURI_COORDINATE_MEDIATION_QUERY = "https://didcomm.org/coordinate-mediation/3.0/recipient-query"
-
 func NewCoordinateMediation(mediator *mediator.Mediator) *CoordinateMediation {
 	return &CoordinateMediation{
 		mediator: mediator,
 	}
 }
 
-func (h *CoordinateMediation) Handle(message didcomm.Message) (response didcomm.Message, err error) {
+func (h *CoordinateMediation) Handle(message didcomm.Message, bearer string) (response didcomm.Message, err error) {
 
 	switch message.Type {
-	case PIURI_COORDINATE_MEDIATION_REQUEST:
-		response, err = h.handleMediationRequest(message)
-	case PIURI_COORDINATE_MEDIATION_UPDATE:
+	case constants.PIURI_COORDINATE_MEDIATION_REQUEST:
+		response, err = h.handleMediationRequest(message, bearer)
+	case constants.PIURI_COORDINATE_MEDIATION_UPDATE:
 		response, err = h.handleRecipientUpdate(message)
-	case PIURI_COORDINATE_MEDIATION_QUERY:
+	case constants.PIURI_COORDINATE_MEDIATION_QUERY:
 		response, err = h.handleRecipientQuery(message)
 	}
 
@@ -272,18 +269,17 @@ func update(did string, dbRecipientDids []string, RecipientDidUpdates []Update)
 	return updatedRecipientDids, recipientDidsToAdd, recipientDidsToDelete, nil
 }
 
-func (h *CoordinateMediation) handleMediationRequest(message didcomm.Message) (response didcomm.Message, err error) {
-	db := h.mediator.Database
-	isMediated, err := db.IsMediated(*message.From)
+func (h *CoordinateMediation) handleMediationRequest(message didcomm.Message, bearer string) (response didcomm.Message, err error) {
+
+	id, err := mediator.VerifySignedToken(bearer, h.mediator.Did, h.mediator.SecretsResolver, h.mediator.DidResolver)
+
 	if err != nil {
-		return PR_NOT_MEDIATED, err
-	}
-	if !isMediated {
+		config.Logger.Error("Error during verification " + err.Error())
 		type body struct {
 			Comment string `json:"comment"`
 		}
 		b := body{
-			Comment: "Mediatee is not registered",
+			Comment: "Mediatee cant be registered.",
 		}
 		bodyJson, err := json.Marshal(b)
 		if err != nil {
@@ -292,25 +288,32 @@ func (h *CoordinateMediation) handleMediationRequest(message didcomm.Message) (r
 		}
 		response = didcomm.Message{
 			Id:   uuid.Must(uuid.NewRandom()).String(),
-			Type: "https://didcomm.org/coordinate-mediation/3.0/mediate-deny",
+			Type: constants.PIURI_COORDINATE_MEDIATION_RESPOSE_DENY,
 			Body: string(bodyJson),
 			From: &h.mediator.Did,
 		}
 		return response, nil
 	}
-	key, err := db.GetRoutingKey(*message.From)
+
+	ok, err := h.mediator.Database.IsMediated(*message.From)
+
 	if err != nil {
-		config.Logger.Error("Can not get routing key from db", err)
-		return PR_INTERNAL_SERVER_ERROR, err
+		config.Logger.Error("error during mediatee check", err)
+		return PR_INVALID_REQUEST, err
 	}
-	if key != "" {
-		response = didcomm.Message{
-			Id:   uuid.Must(uuid.NewRandom()).String(),
-			Type: "https://didcomm.org/coordinate-mediation/3.0/mediate-deny",
-			Body: "{}",
-			From: &h.mediator.Did,
-		}
-		return response, nil
+
+	if ok {
+		config.Logger.Error("Connection already exists", err)
+		return PR_INVALID_REQUEST, err
+	}
+
+	db := h.mediator.Database
+
+	invitation, err := h.mediator.Database.GetMediatee(id)
+
+	if err != nil {
+		config.Logger.Error("invitation not found", err)
+		return PR_INVALID_REQUEST, err
 	}
 
 	service, err := h.mediator.CreateMediatorService()
@@ -320,7 +323,7 @@ func (h *CoordinateMediation) handleMediationRequest(message didcomm.Message) (r
 	}
 
 	// Grant Message
-	routingKey, err := mediator.NumAlgo2(service, *h.mediator)
+	routingKey, err := mediator.NumAlgo2(service, *&h.mediator.SecretsResolver, *&h.mediator.DidResolver)
 	if err != nil {
 		return PR_INTERNAL_SERVER_ERROR, err
 	}
@@ -333,6 +336,7 @@ func (h *CoordinateMediation) handleMediationRequest(message didcomm.Message) (r
 	b := body{
 		RoutingDid: []string{routingKey},
 	}
+
 	bodyJson, err := json.Marshal(b)
 	if err != nil {
 		config.Logger.Error("Can not marshal string", err)
@@ -343,15 +347,56 @@ func (h *CoordinateMediation) handleMediationRequest(message didcomm.Message) (r
 		config.Logger.Error("Can not add meediatee to db", err)
 		return PR_INTERNAL_SERVER_ERROR, err
 	}
+
 	response = didcomm.Message{
 		Id:   uuid.Must(uuid.NewRandom()).String(),
-		Type: "https://didcomm.org/coordinate-mediation/3.0/mediate-grant",
+		Type: constants.PIURI_COORDINATE_MEDIATION_RESPOSE_GRANT,
 		Body: string(bodyJson),
 		// To:   &[]string{*message.From},
 		From: &h.mediator.Did,
 	}
 
-	return response, nil
+	err = h.mediator.ConnectionManager.StoreConnection(invitation.Protocol, *message.From, invitation.Topic, invitation.Properties, invitation.EventType, []string{routingKey}, invitation.Group)
+
+	if err != nil {
+		config.Logger.Error("error finalizing mediatee", err)
+		return PR_INTERNAL_SERVER_ERROR, err
+	}
+
+	h.mediator.Database.DeleteMediatee(id)
+
+	key, err := db.GetRoutingKey(*message.From)
+
+	if err != nil {
+		config.Logger.Error("Can not get routing key from db", err)
+		return PR_INTERNAL_SERVER_ERROR, err
+	}
+
+	if key != "" {
+		response = didcomm.Message{
+			Id:   uuid.Must(uuid.NewRandom()).String(),
+			Type: constants.PIURI_COORDINATE_MEDIATION_RESPOSE_DENY,
+			Body: "{}",
+			From: &h.mediator.Did,
+		}
+		return response, nil
+	}
+
+	mediatee, err := h.mediator.Database.GetMediatee(*message.From)
+
+	if err != nil {
+		config.Logger.Error("error getting mediatee", err)
+		return PR_INTERNAL_SERVER_ERROR, err
+	}
+
+	inv := messaging.InvitationNotify{
+		InvitationId: id,
+		Did:          mediatee.RoutingKey,
+	}
+
+	err = sendCloudEvent(inv, mediatee, config.CurrentConfiguration.CloudForwarding.Nats.Topic+"-invitation")
+
+	return response, err
 }
 
 // remove an element from the list based on RecipientDid

protocol/coordinateMediation_test.go

 package protocol
 
 import (
-	"gaiax/didcommconnector/internal/config"
 	"log/slog"
 	"testing"
 
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/config"
+
 	"github.com/stretchr/testify/assert"
 )
 

protocol/helper.go

@@ -3,8 +3,9 @@ package protocol
 import (
 	"encoding/json"
 	"fmt"
-	"gaiax/didcommconnector/didcomm"
 	"strings"
+
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
 )
 
 func extractBody[T any](message didcomm.Message) (b T, err error) {

protocol/messageHandler.go

@@ -2,15 +2,17 @@ package protocol
 
 import (
 	"errors"
-	"gaiax/didcommconnector/didcomm"
-	"gaiax/didcommconnector/internal/config"
-	intErr "gaiax/didcommconnector/internal/errors"
-	"gaiax/didcommconnector/mediator"
 	"strings"
 	"time"
+
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/config"
+	intErr "gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/errors"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/pkg/constants"
 )
 
-func HandleMessage(bodyString string, mediator *mediator.Mediator) (packMsg string, err error) {
+func HandleMessage(bodyString string, mediator *mediator.Mediator, bearer string) (packMsg string, err error) {
 
 	messageExpired := false
 	messageWrongCreationTime := false
@@ -65,10 +67,10 @@ func HandleMessage(bodyString string, mediator *mediator.Mediator) (packMsg stri
 		responseMsg = PR_EXPIRED_MESSAGE
 	} else if messageWrongCreationTime {
 		responseMsg = PR_MESSAGE_WRONG_CREATION_TIME
-	} else if strings.HasPrefix(msg.Type, PIURI_COORDINATE_MEDIATION) {
+	} else if strings.HasPrefix(msg.Type, constants.PIURI_COORDINATE_MEDIATION) {
 
 		coordinateMediation := NewCoordinateMediation(mediator)
-		responseMsg, err = coordinateMediation.Handle(msg)
+		responseMsg, err = coordinateMediation.Handle(msg, bearer)
 		if err != nil {
 			errMsg := "unable to handle coordinate mediation"
 			config.Logger.Error(errMsg, "err", err)
@@ -127,14 +129,14 @@ func HandleMessage(bodyString string, mediator *mediator.Mediator) (packMsg stri
 	return
 }
 
-func packMessage(mediatorDid string, from string, responseMsg didcomm.Message, mediator *mediator.Mediator) (packedMsg string, err error) {
-	responseMsg.To = &[]string{from}
-	responseMsg.From = &mediatorDid
+func packMessage(from string, to string, responseMsg didcomm.Message, mediator *mediator.Mediator) (packedMsg string, err error) {
+	responseMsg.To = &[]string{to}
+	responseMsg.From = &from
 	timeNow := uint64(time.Now().UTC().Unix())
 	responseMsg.CreatedTime = &timeNow
 
 	if config.CurrentConfiguration.DidComm.IsMessageEncrypted {
-		packedMsg, err = mediator.PackEncryptedMessage(responseMsg, from, mediatorDid)
+		packedMsg, err = mediator.PackEncryptedMessage(responseMsg, to, from)
 		if err != nil {
 			errMsg := "unable to pack encrypted message"
 			config.Logger.Error(errMsg, "err", err)

protocol/messageHandler_test.go

 package protocol_test
 
 import (
-	"gaiax/didcommconnector/internal/config"
-	"gaiax/didcommconnector/mediator"
-	"gaiax/didcommconnector/protocol"
-	"log/slog"
+	"encoding/base64"
+	"encoding/json"
+	"github.com/google/uuid"
 	"strconv"
 	"testing"
 	"time"
 
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/config"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/protocol"
+
 	"github.com/stretchr/testify/assert"
 )
 
 func init() {
 	config.CurrentConfiguration.Database.InMemory = true
-	med = mediator.NewMediator(slog.Default())
-	tp = protocol.NewTrustPing(med)
+	//med := mediator.NewMediator(slog.Default())
+	//tp := protocol.NewTrustPing(med)
+}
+
+func TestHandleMessage(t *testing.T) {
+	data := map[string]any{
+		"id":   uuid.New().String(),
+		"type": "https://didcomm.org/routing/2.0/forward",
+		"body": map[string]string{
+			"next": "did:example:1",
+		},
+		"from": "did:example:2",
+		"to":   []string{"did:example:3"},
+		"attachments": []map[string]any{
+			map[string]any{
+				"id": uuid.New().String(),
+				"data": map[string]string{
+					"base64": base64.StdEncoding.EncodeToString([]byte(`"credential_offer": "offer"`)),
+				},
+			},
+		},
+	}
+
+	bodyString, _ := json.Marshal(data)
+
+	packedMsg, err := protocol.HandleMessage(string(bodyString), med, "")
+	assert.Nil(t, err)
+	print(packedMsg)
+
 }
 
 func TestHandleMessage_MessageExpired(t *testing.T) {
@@ -36,7 +65,7 @@ func TestHandleMessage_MessageExpired(t *testing.T) {
 		"\"attachments\": []" +
 		"}"
 
-	packedMsg, err := protocol.HandleMessage(bodyString, med)
+	packedMsg, err := protocol.HandleMessage(bodyString, med, "")
 
 	// Check if the result matches the expected outcome
 	prType := "https://didcomm.org/report-problem/2.0/problem-report"
@@ -66,7 +95,7 @@ func TestHandleMessage_MessageCreatedWrong(t *testing.T) {
 		"\"attachments\": []" +
 		"}"
 
-	packedMsg, err := protocol.HandleMessage(bodyString, med)
+	packedMsg, err := protocol.HandleMessage(bodyString, med, "")
 
 	// Check if the result matches the expected outcome
 	prType := "https://didcomm.org/report-problem/2.0/problem-report"

protocol/messagePickup.go

@@ -3,11 +3,12 @@ package protocol
 import (
 	"encoding/json"
 	"errors"
-	"gaiax/didcommconnector/didcomm"
-	intErr "gaiax/didcommconnector/internal/errors"
-	"gaiax/didcommconnector/mediator"
 	"strconv"
 	"strings"
+
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
+	intErr "gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/errors"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator"
 )
 
 type MessagePickup struct {

protocol/outOfBand.go

@@ -2,8 +2,9 @@ package protocol
 
 import (
 	"encoding/json"
-	"gaiax/didcommconnector/didcomm"
-	"gaiax/didcommconnector/mediator"
+
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator"
 
 	"github.com/google/uuid"
 )
@@ -19,19 +20,21 @@ func NewOutOfBand(mediator *mediator.Mediator) *OutOfBand {
 	}
 }
 
-func (o *OutOfBand) Handle() (response string, err error) {
+func (o *OutOfBand) Handle(label string, bearer string) (response string, err error) {
 	type body struct {
 		GoalCode string   `json:"goal_code"`
 		Goal     string   `json:"goal"`
 		Label    string   `json:"label"`
 		Accept   []string `json:"accept"`
+		Bearer   string   `json:"auth"`
 	}
 
 	b := body{
 		GoalCode: "request-mediate",
 		Goal:     "RequestMediate",
-		Label:    "Mediator",
+		Label:    label,
 		Accept:   []string{"didcomm/v2"},
+		Bearer:   bearer,
 	}
 
 	bodyJson, err := json.Marshal(b)

protocol/problemReport.go

@@ -2,7 +2,8 @@ package protocol
 
 import (
 	"encoding/json"
-	"gaiax/didcommconnector/didcomm"
+
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
 
 	"github.com/google/uuid"
 )

protocol/trustPing.go

@@ -4,9 +4,10 @@ package protocol
 
 import (
 	"encoding/json"
-	"gaiax/didcommconnector/didcomm"
-	intErr "gaiax/didcommconnector/internal/errors"
-	"gaiax/didcommconnector/mediator"
+
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
+	intErr "gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/errors"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator"
 
 	"github.com/google/uuid"
 )

protocol/trustPing_test.go

@@ -3,14 +3,15 @@ package protocol_test
 import (
 	"encoding/json"
 	"errors"
-	"gaiax/didcommconnector/didcomm"
-	"gaiax/didcommconnector/internal/config"
-	intErr "gaiax/didcommconnector/internal/errors"
-	"gaiax/didcommconnector/mediator"
-	"gaiax/didcommconnector/protocol"
 	"log/slog"
 	"testing"
 
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/didcomm"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/config"
+	intErr "gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/internal/errors"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/mediator"
+	"gitlab.eclipse.org/eclipse/xfsc/common-services/didcomm-connector/protocol"
+
 	"github.com/stretchr/testify/assert"
 )