Add examples

Remove print statements

Author: stevenvegt

example_test.go

@@ -0,0 +1,140 @@
+package trustdidweb_test
+
+import (
+	"fmt"
+	"log"
+
+	tdw "github.com/nuts-foundation/trustdidweb-go"
+)
+
+func ExampleCreate() {
+	// Create a new signer
+	signer, err := tdw.NewSigner(tdw.CRYPTO_SUITE_EDDSA_JCS_2022)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create a new DIDLog
+	doc, err := tdw.NewMinimalDIDDocument("did:tdw:{SCID}:example.com")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	didLog, err := tdw.Create(doc, signer)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the log
+	logFile, err := didLog.MarshalText()
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(logFile))
+}
+
+func ExampleDIDLog_Update() {
+	// Create a new signer
+	signer, err := tdw.NewSigner(tdw.CRYPTO_SUITE_EDDSA_JCS_2022)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create a new DIDDocument
+	doc, err := tdw.NewMinimalDIDDocument("did:tdw:{SCID}:example.com")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create a new DIDLog
+	didLog, err := tdw.Create(doc, signer)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Get the document from the log
+	doc, err = didLog.Document()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Add a service
+	doc["service"] = []interface{}{
+		map[string]interface{}{
+			"id":              fmt.Sprintf("%s#service-1", doc["id"]),
+			"type":            "Service",
+			"serviceEndpoint": "https://example.com/service/1",
+		},
+	}
+
+	// Update the log with a new entry containing the updated document
+	didLog, err = didLog.Update(tdw.LogParams{}, doc, signer)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the log
+	logFile, err := didLog.MarshalText()
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(logFile))
+}
+
+func ExampleDIDLog_Verify() {
+	// Create a new signer
+	signer, err := tdw.NewSigner(tdw.CRYPTO_SUITE_EDDSA_JCS_2022)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create a new DIDDocument
+	doc, err := tdw.NewMinimalDIDDocument("did:tdw:{SCID}:example.com")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	didLog, err := tdw.Create(doc, signer)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err := didLog.Verify(); err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println("Log is valid")
+
+	// Output:
+	// Log is valid
+}
+
+func ExampleDIDLog_Deactivate() {
+	// Create a new signer
+	signer, err := tdw.NewSigner(tdw.CRYPTO_SUITE_EDDSA_JCS_2022)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create a new DIDDocument
+	doc, err := tdw.NewMinimalDIDDocument("did:tdw:{SCID}:example.com")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	didLog, err := tdw.Create(doc, signer)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Deactivate the log
+	didLog, err = didLog.Deactivate(signer)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Printf("Is log deactivated: %t\n", didLog.IsDeactivated())
+
+	// Output:
+	// Is log deactivated: true
+}

logentry.go

@@ -89,13 +89,8 @@ func (l LogEntry) MarshalJSONL() ([]byte, error) {
 }
 
 func (entry LogEntry) calculateEntryHash(prevVersionId versionId) (string, error) {
-	fmt.Print("\ncalculateEntryHash:\n")
-
-	fmt.Printf("previous version id: %s\n", prevVersionId.String())
 	// a hash is calulated over the entry without proof
 	entry.Proof = nil
-	// fmt.Print("\n\ncalculateEntryHash:\n\n")
-	// fmt.Printf("entry: %v\n", entry)
 
 	// Canonicalized version of the first log entry
 	entry.VersionId = prevVersionId
@@ -104,14 +99,10 @@ func (entry LogEntry) calculateEntryHash(prevVersionId versionId) (string, error
 		return "", err
 	}
 
-	fmt.Printf("logentry: %s\n", b)
-
 	entryHash := newEntryHash(b, uint64(multicodec.Sha2_256))
 	if entryHash == "" {
 		return "", fmt.Errorf("failed to calculate entry hash")
 	}
 
-	fmt.Printf("calculated hash: %s\n", entryHash)
-
 	return string(entryHash), nil
 }

proof.go

@@ -104,7 +104,6 @@ func (proof Proof) Verify(challenge string, updateKeys []string, doc DIDDocument
 		return fmt.Errorf("unsupported proof purpose: %s", proof.ProofPurpose)
 	}
 	if proof.Challenge != challenge {
-		fmt.Printf("proof.challenge: %s, expected: %s\n", proof.Challenge, challenge)
 		return fmt.Errorf("challenge mismatch")
 	}
 
@@ -149,8 +148,6 @@ func (proof Proof) Verify(challenge string, updateKeys []string, doc DIDDocument
 	if err != nil {
 		return fmt.Errorf("failed to decode proof value: %w", err)
 	}
-	fmt.Printf("signature: %x\n", signature)
-	fmt.Printf("signature length: %d\n", len(signature))
 
 	switch pubKey := pubKey.(type) {
 	case *ecdsa.PublicKey:
@@ -213,13 +210,9 @@ func hashLogVersion(document map[string]interface{}, proof Proof, hashfn hash.Ha
 	hashfn.Write(optionData)
 	optionsHash := hashfn.Sum(nil)
 
-	fmt.Printf("dataHash: %x\n", dataHash)
-	fmt.Printf("optionsHash: %x\n", optionsHash)
-
 	logger().Debug("hash", "data", base64.URLEncoding.WithPadding(base64.NoPadding).EncodeToString(dataHash[:]))
 	logger().Debug("hash", "options", base64.URLEncoding.WithPadding(base64.NoPadding).EncodeToString(optionsHash[:]))
 
 	input := append(dataHash[:], optionsHash[:]...)
-	fmt.Printf("input: %x\n", input)
 	return input, nil
 }

trustdidweb.go

@@ -9,11 +9,11 @@ import (
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/sha512"
-	"encoding/base64"
 	"encoding/binary"
 	"errors"
 	"fmt"
 	"hash"
+	"io/ioutil"
 	"log/slog"
 	"strconv"
 	"strings"
@@ -247,7 +247,7 @@ func (log DIDLog) Document() (DIDDocument, error) {
 }
 
 func logger() *slog.Logger {
-	return slog.Default().WithGroup("trustdidweb")
+	return slog.New(slog.NewTextHandler(ioutil.Discard, &slog.HandlerOptions{Level: slog.LevelDebug}))
 }
 
 func renderPathTemplate(didTemplate, scid string) string {
@@ -346,8 +346,6 @@ func Create(doc DIDDocument, signer crypto.Signer, nextKeyhashes ...NextKeyHash)
 }
 
 func (log DIDLog) Update(params LogParams, modifiedDoc map[string]interface{}, signer crypto.Signer) (DIDLog, error) {
-	fmt.Print("\n\nUpdate:\n\n")
-
 	currentDoc, err := log.Document()
 	if err != nil {
 		return DIDLog{}, err
@@ -412,8 +410,6 @@ func NewSigner(cryptoSuite string) (crypto.Signer, error) {
 
 // buildProof creates a proof for the latest entry in the log
 func (log DIDLog) buildProof(signer crypto.Signer) (Proof, error) {
-	fmt.Print("\n\nbuildProof:\n\n")
-
 	entry := log[len(log)-1]
 
 	verificationMethod, err := verificationMethodFromSigner(signer)
@@ -464,18 +460,12 @@ func (log DIDLog) buildProof(signer crypto.Signer) (Proof, error) {
 		return Proof{}, fmt.Errorf("failed to hash entry: %w", err)
 	}
 
-	fmt.Printf("input length: %d\n", len(input))
-
-	fmt.Printf("input: %s\n", base64.URLEncoding.WithPadding(base64.NoPadding).EncodeToString(input))
-
 	// sign the entry
 	signature, err := signer.Sign(rand.Reader, input, signerOpts)
 	if err != nil {
 		return Proof{}, fmt.Errorf("failed to sign entry: %w", err)
 	}
 
-	fmt.Printf("signature: %s\n", base64.URLEncoding.WithPadding(base64.NoPadding).EncodeToString(signature))
-
 	encodedProof, err := multibase.Encode(multibase.Base58BTC, signature)
 	if err != nil {
 		return Proof{}, fmt.Errorf("failed to encode signature: %w", err)
@@ -487,9 +477,6 @@ func (log DIDLog) buildProof(signer crypto.Signer) (Proof, error) {
 
 // calculateEntryHash calculates the hash of the
 func (log DIDLog) calculateVersionId(version int) (versionId, error) {
-	fmt.Print("\ncalculateVersionId:\n")
-	fmt.Printf("version: %d\n", version)
-
 	var entry LogEntry
 	var prevVersionId versionId
 	switch version {
@@ -513,7 +500,6 @@ func (log DIDLog) calculateVersionId(version int) (versionId, error) {
 }
 
 func (log DIDLog) Verify() error {
-	fmt.Print("\n\nVerify:\n\n")
 	// empty log should not be considered valid
 	if len(log) == 0 {
 		return fmt.Errorf("empty log")
@@ -522,14 +508,11 @@ func (log DIDLog) Verify() error {
 	var scid string
 
 	for i, entry := range log {
-		fmt.Printf("\nentry i: %d\n", i)
-
 		if i+1 != entry.VersionId.Version {
 			return fmt.Errorf("invalid log sequence number, expected: %d, got: %d", i+1, entry.VersionId.Version)
 		}
 
 		if i == 0 {
-			fmt.Printf("verify scid first entry\n")
 			if entry.Params.Scid == "" {
 				return fmt.Errorf("missing scid in the first log entry params")
 			}
@@ -633,8 +616,6 @@ func (log DIDLog) Verify() error {
 }
 
 func (log DIDLog) Deactivate(signer crypto.Signer) (DIDLog, error) {
-	fmt.Print("\n\nDeactivate:\n\n")
-
 	if len(log) == 0 {
 		return nil, fmt.Errorf("empty log")
 	}