chore: Refactor sidetree client send operation request function (#292)

Refactor sidetree client send operation request function so it can be passed as an option.

Closes #291

Signed-off-by: Sandra Vrtikapa <[email protected]>

Signed-off-by: Sandra Vrtikapa <[email protected]>

Author: sandrask

component/vdr/sidetree/client.go

@@ -47,12 +47,15 @@ type Client struct {
 	client            *http.Client
 	authToken         string
 	authTokenProvider authTokenProvider
+	sendRequest       func(req []byte, getEndpoints func() ([]string, error)) ([]byte, error)
 }
 
-// New return did bloc client.
+// New return sidetree client.
 func New(opts ...Option) *Client {
 	c := &Client{client: &http.Client{}}
 
+	c.sendRequest = c.defaultSendRequest
+
 	// Apply options
 	for _, opt := range opts {
 		opt(c)
@@ -74,21 +77,12 @@ func (c *Client) CreateDID(opts ...create.Option) (*docdid.DocResolution, error)
 		return nil, err
 	}
 
-	// TODO add logic for using different sidetree endpoint
-	// for now will use the first one
-	endpoints, err := createDIDOpts.GetEndpoints()
-	if err != nil {
-		return nil, err
-	}
-
-	sidetreeEndpoint := endpoints[0]
-
 	req, err := buildCreateRequest(createDIDOpts.MultiHashAlgorithm, createDIDOpts)
 	if err != nil {
 		return nil, fmt.Errorf("failed to build sidetree request: %w", err)
 	}
 
-	responseBytes, err := c.sendRequest(req, sidetreeEndpoint)
+	responseBytes, err := c.sendRequest(req, createDIDOpts.GetEndpoints)
 	if err != nil {
 		return nil, fmt.Errorf("failed to send create sidetree request: %w", err)
 	}
@@ -109,6 +103,7 @@ func (c *Client) CreateDID(opts ...create.Option) (*docdid.DocResolution, error)
 		return nil, fmt.Errorf("failed to parse did document: %w", err)
 	}
 
+	// TODO: Talk to Firas about not including document metadata in create
 	return &docdid.DocResolution{DIDDocument: didDoc}, nil
 }
 
@@ -125,21 +120,12 @@ func (c *Client) UpdateDID(did string, opts ...update.Option) error {
 		return err
 	}
 
-	// TODO add logic for using different sidetree endpoint
-	// for now will use the first one
-	endpoints, err := updateDIDOpts.GetEndpoints()
-	if err != nil {
-		return err
-	}
-
-	sidetreeEndpoint := endpoints[0]
-
 	req, err := c.buildUpdateRequest(did, updateDIDOpts.MultiHashAlgorithm, updateDIDOpts)
 	if err != nil {
 		return fmt.Errorf("failed to build update request: %w", err)
 	}
 
-	_, err = c.sendRequest(req, sidetreeEndpoint)
+	_, err = c.sendRequest(req, updateDIDOpts.GetEndpoints)
 	if err != nil {
 		return fmt.Errorf("failed to send update did request: %w", err)
 	}
@@ -160,21 +146,12 @@ func (c *Client) RecoverDID(did string, opts ...recovery.Option) error {
 		return err
 	}
 
-	// TODO add logic for using different sidetree endpoint
-	// for now will use the first one
-	endpoints, err := recoverDIDOpts.GetEndpoints()
-	if err != nil {
-		return err
-	}
-
-	sidetreeEndpoint := endpoints[0]
-
 	req, err := buildRecoverRequest(did, recoverDIDOpts.MultiHashAlgorithm, recoverDIDOpts)
 	if err != nil {
 		return fmt.Errorf("failed to build sidetree request: %w", err)
 	}
 
-	_, err = c.sendRequest(req, sidetreeEndpoint)
+	_, err = c.sendRequest(req, recoverDIDOpts.GetEndpoints)
 	if err != nil {
 		return fmt.Errorf("failed to send recover sidetree request: %w", err)
 	}
@@ -195,21 +172,12 @@ func (c *Client) DeactivateDID(did string, opts ...deactivate.Option) error {
 		return err
 	}
 
-	// TODO add logic for using different sidetree endpoint
-	// for now will use the first one
-	endpoints, err := deactivateDIDOpts.GetEndpoints()
-	if err != nil {
-		return err
-	}
-
-	sidetreeEndpoint := endpoints[0]
-
 	req, err := buildDeactivateRequest(did, deactivateDIDOpts)
 	if err != nil {
 		return fmt.Errorf("failed to build sidetree request: %w", err)
 	}
 
-	_, err = c.sendRequest(req, sidetreeEndpoint)
+	_, err = c.sendRequest(req, deactivateDIDOpts.GetEndpoints)
 	if err != nil {
 		return fmt.Errorf("failed to send deactivate sidetree request: %w", err)
 	}
@@ -226,10 +194,6 @@ func validateCreateReq(createDIDOpts *create.Opts) error {
 		return fmt.Errorf("update public key is required")
 	}
 
-	if createDIDOpts.GetEndpoints == nil {
-		return fmt.Errorf("sidetree get endpoints func is required")
-	}
-
 	return nil
 }
 
@@ -246,10 +210,6 @@ func validateUpdateReq(updateDIDOpts *update.Opts) error {
 		return fmt.Errorf("operation commitment is required")
 	}
 
-	if updateDIDOpts.GetEndpoints == nil {
-		return fmt.Errorf("sidetree get endpoints func is required")
-	}
-
 	return nil
 }
 
@@ -270,10 +230,6 @@ func validateRecoverReq(recoverDIDOpts *recovery.Opts) error {
 		return fmt.Errorf("operation commitment is required")
 	}
 
-	if recoverDIDOpts.GetEndpoints == nil {
-		return fmt.Errorf("sidetree get endpoints func is required")
-	}
-
 	return nil
 }
 
@@ -286,10 +242,6 @@ func validateDeactivateReq(deactivateDIDOpts *deactivate.Opts) error {
 		return fmt.Errorf("operation commitment is required")
 	}
 
-	if deactivateDIDOpts.GetEndpoints == nil {
-		return fmt.Errorf("sidetree get endpoints func is required")
-	}
-
 	return nil
 }
 
@@ -457,7 +409,20 @@ func buildDeactivateRequest(did string, deactivateDIDOpts *deactivate.Opts) ([]b
 	})
 }
 
-func (c *Client) sendRequest(req []byte, endpointURL string) ([]byte, error) {
+func (c *Client) defaultSendRequest(req []byte, getEndpoints func() ([]string, error)) ([]byte, error) {
+	if getEndpoints == nil {
+		return nil, fmt.Errorf("sidetree get endpoints func is required")
+	}
+
+	endpoints, err := getEndpoints()
+	if err != nil {
+		return nil, fmt.Errorf("sidetree get endpoints: %w", err)
+	}
+
+	// TODO add logic for using different sidetree endpoint
+	// for now will use the first one
+	endpointURL := endpoints[0]
+
 	httpReq, err := http.NewRequestWithContext(context.Background(),
 		http.MethodPost, endpointURL, bytes.NewReader(req))
 	if err != nil {

component/vdr/sidetree/client_test.go

@@ -68,15 +68,23 @@ func TestClient_DeactivateDID(t *testing.T) {
 	t.Run("test error from get endpoints", func(t *testing.T) {
 		v := sidetree.New()
 
-		_, privKey, err := ed25519.GenerateKey(rand.Reader)
+		pubKey, privKey, err := ed25519.GenerateKey(rand.Reader)
 		require.NoError(t, err)
 
-		err = v.DeactivateDID("did:ex:123", deactivate.WithSigner(newSignerMock(t, privKey)),
-			deactivate.WithOperationCommitment("value"))
+		signingPubKeyJWK, err := pubkey.GetPublicKeyJWK(pubKey)
+		require.NoError(t, err)
+
+		rv, err := commitment.GetRevealValue(signingPubKeyJWK, 18)
+		require.NoError(t, err)
+
+		err = v.DeactivateDID("did:ex:123",
+			deactivate.WithSigner(newSignerMock(t, privKey)),
+			deactivate.WithOperationCommitment(rv))
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "sidetree get endpoints func is required")
 
-		err = v.DeactivateDID("did:ex:123", deactivate.WithOperationCommitment("value"),
+		err = v.DeactivateDID("did:ex:123",
+			deactivate.WithOperationCommitment(rv),
 			deactivate.WithSigner(newSignerMock(t, privKey)),
 			deactivate.WithSidetreeEndpoint(func() ([]string, error) {
 				return nil, fmt.Errorf("failed to get endpoint")
@@ -213,20 +221,41 @@ func TestClient_RecoverDID(t *testing.T) {
 	t.Run("test error from get endpoints", func(t *testing.T) {
 		v := sidetree.New()
 
-		pubKey, privKey, err := ed25519.GenerateKey(rand.Reader)
+		pubKey, _, err := ed25519.GenerateKey(rand.Reader)
 		require.NoError(t, err)
 
-		err = v.RecoverDID("did:ex:123", recovery.WithOperationCommitment("value"),
-			recovery.WithNextUpdatePublicKey(pubKey), recovery.WithNextRecoveryPublicKey(pubKey),
-			recovery.WithSigner(newSignerMock(t, privKey)))
+		signingKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+		require.NoError(t, err)
+
+		signingPubKeyJWK, err := pubkey.GetPublicKeyJWK(&signingKey.PublicKey)
+		require.NoError(t, err)
+
+		rv, err := commitment.GetRevealValue(signingPubKeyJWK, 18)
+		require.NoError(t, err)
+
+		err = v.RecoverDID("did:ex:123",
+			recovery.WithSigner(newSignerMock(t, signingKey)), recovery.WithOperationCommitment(rv),
+			recovery.WithNextRecoveryPublicKey(pubKey),
+			recovery.WithNextUpdatePublicKey(pubKey), recovery.WithPublicKey(&doc.PublicKey{
+				ID:   "key3",
+				Type: doc.Ed25519VerificationKey2018,
+				JWK:  jwk.JWK{JSONWebKey: gojose.JSONWebKey{Key: pubKey}},
+			}))
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "sidetree get endpoints func is required")
 
-		err = v.RecoverDID("did:ex:123", recovery.WithOperationCommitment("value"),
-			recovery.WithNextUpdatePublicKey(pubKey), recovery.WithNextRecoveryPublicKey(pubKey),
-			recovery.WithSigner(newSignerMock(t, privKey)), recovery.WithSidetreeEndpoint(func() ([]string, error) {
+		err = v.RecoverDID("did:ex:123",
+			recovery.WithSigner(newSignerMock(t, signingKey)), recovery.WithOperationCommitment(rv),
+			recovery.WithNextRecoveryPublicKey(pubKey),
+			recovery.WithNextUpdatePublicKey(pubKey), recovery.WithPublicKey(&doc.PublicKey{
+				ID:   "key3",
+				Type: doc.Ed25519VerificationKey2018,
+				JWK:  jwk.JWK{JSONWebKey: gojose.JSONWebKey{Key: pubKey}},
+			}),
+			recovery.WithSidetreeEndpoint(func() ([]string, error) {
 				return nil, fmt.Errorf("failed to get endpoint")
 			}))
+
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "failed to get endpoint")
 	})
@@ -438,18 +467,34 @@ func TestClient_UpdateDID(t *testing.T) {
 	t.Run("test error from get endpoints", func(t *testing.T) {
 		v := sidetree.New()
 
-		pubKey, privKey, err := ed25519.GenerateKey(rand.Reader)
+		pubKey, _, err := ed25519.GenerateKey(rand.Reader)
+		require.NoError(t, err)
+
+		signingKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 		require.NoError(t, err)
 
-		err = v.UpdateDID("did:ex:123", update.WithOperationCommitment("value"), update.WithNextUpdatePublicKey(pubKey),
-			update.WithSigner(newSignerMock(t, privKey)))
+		signingPubKeyJWK, err := pubkey.GetPublicKeyJWK(&signingKey.PublicKey)
+		require.NoError(t, err)
+
+		rv, err := commitment.GetRevealValue(signingPubKeyJWK, 18)
+		require.NoError(t, err)
+
+		err = v.UpdateDID("did:ex:123",
+			update.WithSigner(newSignerMock(t, signingKey)),
+			update.WithOperationCommitment(rv),
+			update.WithNextUpdatePublicKey(pubKey),
+			update.WithRemoveService("svc1"))
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "sidetree get endpoints func is required")
 
-		err = v.UpdateDID("did:ex:123", update.WithOperationCommitment("value"), update.WithNextUpdatePublicKey(pubKey),
-			update.WithSigner(newSignerMock(t, privKey)), update.WithSidetreeEndpoint(func() ([]string, error) {
+		err = v.UpdateDID("did:ex:123",
+			update.WithSigner(newSignerMock(t, signingKey)),
+			update.WithOperationCommitment(rv),
+			update.WithNextUpdatePublicKey(pubKey),
+			update.WithSidetreeEndpoint(func() ([]string, error) {
 				return nil, fmt.Errorf("failed to get endpoints")
-			}))
+			}),
+			update.WithRemoveService("svc1"))
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "failed to get endpoints")
 	})
@@ -613,18 +658,36 @@ func TestClient_CreateDID(t *testing.T) {
 	t.Run("test error from get endpoints", func(t *testing.T) {
 		v := sidetree.New()
 
-		pubKey, _, err := ed25519.GenerateKey(rand.Reader)
+		ed25519RecoveryPubKey, _, err := ed25519.GenerateKey(rand.Reader)
 		require.NoError(t, err)
 
-		didResol, err := v.CreateDID(create.WithUpdatePublicKey(pubKey), create.WithRecoveryPublicKey(pubKey))
-		require.Error(t, err)
+		ecUpdatePrivKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+		require.NoError(t, err)
+
+		didResol, err := v.CreateDID(create.WithRecoveryPublicKey(ed25519RecoveryPubKey),
+			create.WithUpdatePublicKey(ecUpdatePrivKey.Public()),
+			create.WithPublicKey(&doc.PublicKey{
+				ID:       "key1",
+				Type:     doc.JWSVerificationKey2020,
+				JWK:      jwk.JWK{JSONWebKey: gojose.JSONWebKey{Key: ed25519RecoveryPubKey}},
+				Purposes: []string{doc.KeyPurposeAuthentication},
+			}))
+
 		require.Contains(t, err.Error(), "sidetree get endpoints func is required")
 		require.Nil(t, didResol)
 
-		didResol, err = v.CreateDID(create.WithUpdatePublicKey(pubKey), create.WithRecoveryPublicKey(pubKey),
+		didResol, err = v.CreateDID(create.WithRecoveryPublicKey(ed25519RecoveryPubKey),
+			create.WithUpdatePublicKey(ecUpdatePrivKey.Public()),
+			create.WithPublicKey(&doc.PublicKey{
+				ID:       "key1",
+				Type:     doc.JWSVerificationKey2020,
+				JWK:      jwk.JWK{JSONWebKey: gojose.JSONWebKey{Key: ed25519RecoveryPubKey}},
+				Purposes: []string{doc.KeyPurposeAuthentication},
+			}),
 			create.WithSidetreeEndpoint(func() ([]string, error) {
 				return nil, fmt.Errorf("failed to get endpoints")
 			}))
+
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "failed to get endpoints")
 		require.Nil(t, didResol)
@@ -679,6 +742,26 @@ func TestClient_CreateDID(t *testing.T) {
 		require.Nil(t, didResol)
 	})
 
+	t.Run("test error from sidetree operation request function", func(t *testing.T) {
+		v := sidetree.New(sidetree.WithSidetreeOperationRequestFnc(func(req []byte, getEndpoints func() ([]string, error)) ([]byte, error) {
+			return nil, fmt.Errorf("send operation request error")
+		}))
+
+		ed25519RecoveryPubKey, _, err := ed25519.GenerateKey(rand.Reader)
+		require.NoError(t, err)
+
+		ed25519UpdatePubKey, _, err := ed25519.GenerateKey(rand.Reader)
+		require.NoError(t, err)
+
+		didResol, err := v.CreateDID(create.WithRecoveryPublicKey(ed25519RecoveryPubKey),
+			create.WithUpdatePublicKey(ed25519UpdatePubKey), create.WithSidetreeEndpoint(func() ([]string, error) {
+				return []string{"https://www.domain.com"}, nil
+			}))
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "failed to send create sidetree request: send operation request error")
+		require.Nil(t, didResol)
+	})
+
 	t.Run("test success", func(t *testing.T) {
 		serv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			bytes, err := (&did.Doc{ID: "did1", Context: []string{did.ContextV1}}).JSONBytes()

component/vdr/sidetree/option.go

@@ -32,3 +32,10 @@ func WithAuthTokenProvider(p authTokenProvider) Option {
 		opts.authTokenProvider = p
 	}
 }
+
+// WithSidetreeOperationRequestFnc overrides default sidetree operation request.
+func WithSidetreeOperationRequestFnc(fnc func(req []byte, getEndpoints func() ([]string, error)) ([]byte, error)) Option {
+	return func(opts *Client) {
+		opts.sendRequest = fnc
+	}
+}