From c225980bd9f3511862086b3c6f78f3e4f298770f Mon Sep 17 00:00:00 2001
From: pstlouis <patrick.st-louis@opsecid.ca>
Date: Thu, 9 Jan 2025 14:55:42 -0500
Subject: [PATCH] log registration and demo update

Signed-off-by: pstlouis <patrick.st-louis@opsecid.ca>
---
 demo/README.md                    | 221 ++++++++++++------------------
 demo/register.sh                  |  79 +++++++++++
 server/app/__init__.py            |   3 +-
 server/app/models/did_document.py |   2 +-
 server/app/routers/identifiers.py |  54 ++++++--
 server/app/routers/resolvers.py   |  25 ----
 server/pyproject.toml             |   1 +
 7 files changed, 206 insertions(+), 179 deletions(-)
 create mode 100755 demo/register.sh
 delete mode 100644 server/app/routers/resolvers.py

diff --git a/demo/README.md b/demo/README.md
index ccbb017..7096e0a 100644
--- a/demo/README.md
+++ b/demo/README.md
@@ -16,8 +16,8 @@ You will need a docker installation, curl, jq and a bash shell.
 
 Once this is all checked, you can clone the repo, move to the demo repository and start the services:
 ```bash
-git clone https://github.com/OpSecId/trustdidweb-server-py.git
-cd trustdidweb-server-py/demo/ && ./manage start
+git clone https://github.com/identity-foundation/didwebvh-server-py.git
+cd didwebvh-server-py/demo/ && ./manage start
     
 ```
 
@@ -32,7 +32,7 @@ curl -H Host:agent.docker.localhost \
 ```
 
 *You can visit the following pages in your browser*
-- http://agent.docker.localhost
+- http://agent.docker.localhost/api/doc
 - http://server.docker.localhost/docs
 
 ## Create a DID
@@ -43,153 +43,78 @@ DID web requires a public endpoint to be globally resolveable. For this demo, we
 
 This demo also serves as an introduction to Data Integrity proof sets.
 
+At any time, you can reset this demo with the `./manage restart` command.
+
 ### Request a did namespace and identifier
 ```bash
-namespace='demo'
-identifier='issuer'
-curl -H Host:server.docker.localhost \
-    http://127.0.0.1?namespace=$namespace&identifier=$identifier | jq .
-```
-```json
-{
-  "document": {
-    "@context": [
-      "https://www.w3.org/ns/did/v1"
-    ],
-    "id": "did:web:server.docker.localhost:demo:issuer"
-  },
-  "options": {
-    "type": "DataIntegrityProof",
-    "cryptosuite": "eddsa-jcs-2022",
-    "proofPurpose": "authentication",
-    "created": "2024-09-06T20:57:52+00:00",
-    "expires": "2024-09-06T21:07:52+00:00",
-    "domain": "server.docker.localhost",
-    "challenge": "de96aa5e-3c6d-55d7-9ef7-77dd98cabf96"
-  }
-}
+DID_REQUEST=$(curl -H Host:server.docker.localhost \
+    'http://127.0.0.1?namespace=demo&identifier=issuer' | jq .)
+
+DID_DOCUMENT=$(echo $DID_REQUEST | jq .didDocument)
+PROOF_OPTIONS=$(echo $DID_REQUEST | jq .proofOptions)
+
 ```
-From this point on, you have 10 minutes to complete the rest of this demo before the proof configuration is expired. You can restart at any moment with the `./manage restart` command.
 
-## Create a new verification Method
-Open the browser and register a new verification method with the agent.
-- http://issuer.docker.localhost/api/doc#/wallet/post_keys
+The proof options generated have a 10 minutes validity period, after which you will need to request a new set of options.
 
-Here's a sample request you can copy into the OpenAPI interface.
+## Create an update key for this did
+```bash
+# http://agent.docker.localhost/api/doc#/wallet/post_wallet_keys
 
-```json
-{
-    "kid": "did:web:server.docker.localhost:demo:issuer#key-01"
-}
-```
+UPDATE_KEY=$(curl -X 'POST' -H Host:agent.docker.localhost \
+  'http://127.0.0.1/wallet/keys' \
+  -d '{}' | jq -r .multikey)
+CONTROLLER_VERIFICATION_METHOD="did:key:$UPDATE_KEY#$UPDATE_KEY"
 
-## Create and sign the did document
-Create your DID document, adding the verification method created at the previous step. Also add an `authentication` and `assertionMethod` relationship to this verification method.
-```json
-{
-    "@context": [
-      "https://www.w3.org/ns/did/v1"
-    ],
-    "id": "did:web:server.docker.localhost:demo:issuer",
-    "authentication": ["did:web:server.docker.localhost:demo:issuer#key-01"],
-    "assertionMethod": ["did:web:server.docker.localhost:demo:issuer#key-01"],
-    "verificationMethod": [
-        {
-            "id": "did:web:server.docker.localhost:demo:issuer#key-01",
-            "type": "MultiKey",
-            "controller": "did:web:server.docker.localhost:demo:issuer",
-            "publicKeyMultibase": "z6MkgKA7yrw5kYSiDuQFcye4bMaJpcfHFry3Bx45pdWh3s8i"
-        }
-    ],
-}
 ```
+
+## Sign the did document
+You can optionally add information to your did document containing the content you want to publish. Refer to the did core spec to get familiar with such features. For this demo, we will leave it as is.
+
 Sign with the proof options obtained from step 1.
-- http://issuer.docker.localhost/api/doc#/wallet/post_wallet_di_add_proof
-
-See below for a template to use as your request body.
-- *You will need to use the options you obtained since there's an expiration of 10 minutes and a unique challenge was created.*
-- *Also, you will need to add the verificationMethod you created.*
-```json
-{
-  "document": {
-        "@context": [
-          "https://www.w3.org/ns/did/v1"
-        ],
-        "id": "did:web:server.docker.localhost:demo:issuer",
-        "authentication": ["did:web:server.docker.localhost:demo:issuer#key-01"],
-        "assertionMethod": ["did:web:server.docker.localhost:demo:issuer#key-01"],
-        "verificationMethod": [
-            {
-                "id": "did:web:server.docker.localhost:demo:issuer#key-01",
-                "type": "MultiKey",
-                "controller": "did:web:server.docker.localhost:demo:issuer",
-                "publicKeyMultibase": "z6MkgKA7yrw5kYSiDuQFcye4bMaJpcfHFry3Bx45pdWh3s8i"
-            }
-        ]
-    },
-  "options": {
-    "type": "DataIntegrityProof",
-    "cryptosuite": "eddsa-jcs-2022",
-    "proofPurpose": "authentication",
-    "created": "⚠️",
-    "expires": "⚠️",
-    "domain": "server.docker.localhost",
-    "challenge": "⚠️",
-    "verificationMethod": "did:key:⚠️#⚠️"
-  }
-}
+```bash
+# http://issuer.docker.localhost/api/doc#/wallet/post_wallet_di_add_proof
+
+# Add verificationMethod to the proof options
+CONTROLLER_PROOF_OPTIONS=$(jq '. += {"verificationMethod": "'"$CONTROLLER_VERIFICATION_METHOD"'"}' <<< "$PROOF_OPTIONS")
+
+# Construct the payload for the request
+PAYLOAD=$(cat <<EOF 
+{"document": $DID_DOCUMENT, "options": $CONTROLLER_PROOF_OPTIONS}
+EOF
+)
+
+# Request a signature on the did document
+SIGNED_DID_DOC=$(curl -X 'POST' -H Host:agent.docker.localhost \
+  -H 'Content-Type: application/json' \
+  'http://127.0.0.1/vc/di/add-proof' \
+  -d ''"$PAYLOAD"'' | jq .securedDocument)
 
 ```
 
 ## Request an endorser signature
 Request an endorser signature on the signed did document.
-- http://endorser.docker.localhost/api/doc#/wallet/post_wallet_di_add_proof
-
-See below for a template to use as your request body.
-- *Again, you will need to use the options you obtained since there's an expiration of 10 minutes and a unique challenge was created.*
-- *Also, you will need to add the `verificationMethod` from the endorser, which is derived from the server's root did: `did:web:server.docker.localhost#key-01`. This has been provisioned on the endorser agent during startup.*
-```json
-{
-  "document": {
-        "@context": [
-          "https://www.w3.org/ns/did/v1"
-        ],
-        "id": "did:web:server.docker.localhost:demo:issuer",
-        "authentication": ["did:web:server.docker.localhost:demo:issuer#key-01"],
-        "assertionMethod": ["did:web:server.docker.localhost:demo:issuer#key-01"],
-        "verificationMethod": [
-            {
-                "id": "did:web:server.docker.localhost:demo:issuer#key-01",
-                "type": "MultiKey",
-                "controller": "did:web:server.docker.localhost:demo:issuer",
-                "publicKeyMultibase": "z6MkgKA7yrw5kYSiDuQFcye4bMaJpcfHFry3Bx45pdWh3s8i"
-            }
-        ],
-        "proof": [
-          {
-            "type": "DataIntegrityProof",
-            "cryptosuite": "eddsa-jcs-2022",
-            "proofPurpose": "authentication",
-            "verificationMethod": "did:key:⚠️#⚠️",
-            "created": "⚠️",
-            "expires": "⚠️",
-            "domain": "server.docker.localhost",
-            "challenge": "⚠️",
-            "proofValue": "z3GBx56nXZDead55EXi85tLyeXiS2oTa3SEkQYtgiqGANE6k4GxZXFNs1Uh7tdAA2tsgo8HarkZs8YrCwuA8biQaj"
-          }
-        ]
-    },
-  "options": {
-    "type": "DataIntegrityProof",
-    "cryptosuite": "eddsa-jcs-2022",
-    "proofPurpose": "authentication",
-    "verificationMethod": "did:key:z6MkgKA7yrw5kYSiDuQFcye4bMaJpcfHFry3Bx45pdWh3s8i#z6MkgKA7yrw5kYSiDuQFcye4bMaJpcfHFry3Bx45pdWh3s8i ",
-    "created": "⚠️",
-    "expires": "⚠️",
-    "domain": "server.docker.localhost",
-    "challenge": "⚠️"
-  }
-}
+
+```bash
+# http://issuer.docker.localhost/api/doc#/wallet/post_wallet_di_add_proof
+
+# Change verificationMethod to the proof options
+ENDORSER_KEY='z6MkgKA7yrw5kYSiDuQFcye4bMaJpcfHFry3Bx45pdWh3s8i'
+ENDORSER_VERIFICATION_METHOD="did:key:$ENDORSER_KEY#$ENDORSER_KEY"
+ENDORSER_PROOF_OPTIONS=$(jq '. += {"verificationMethod": "'"$ENDORSER_VERIFICATION_METHOD"'"}' <<< "$PROOF_OPTIONS")
+
+# Construct the payload for the request
+PAYLOAD=$(cat <<EOF 
+{"document": $SIGNED_DID_DOC, "options": $ENDORSER_PROOF_OPTIONS}
+EOF
+)
+
+# Request a signature on the did document
+ENDORSED_DID_DOC=$(curl -X 'POST' -H Host:agent.docker.localhost \
+  -H 'Content-Type: application/json' \
+  'http://127.0.0.1/vc/di/add-proof' \
+  -d ''"$PAYLOAD"'' | jq .securedDocument)
+
 ```
 
 ## Send the request back to the server
@@ -200,8 +125,32 @@ If you completed the steps properly and within 10 minutes, your DID will now be
 
 If you get an error, try restarting the demo using the `./manage restart` command.
 
+```bash
+# Construct the payload for the request
+PAYLOAD=$(cat <<EOF 
+{"didDocument": $ENDORSED_DID_DOC}
+EOF
+)
+
+# Request a signature on the did document
+curl -X 'POST' -H Host:server.docker.localhost \
+  -H 'Content-Type: application/json' \
+  'http://127.0.0.1/' \
+  -d ''"$PAYLOAD"'' | jq .
+
+```
 
 ## Resolve (locally) your new DID
 ```bash
 curl -H Host:server.docker.localhost http://127.0.0.1/demo/issuer/did.json | jq .
 ```
+
+## Initialise the DID Log
+
+```bash
+LOG_ENTRY=$(curl -H Host:server.docker.localhost http://127.0.0.1/demo/issuer | jq .logEntry)
+PAYLOAD=$(cat <<EOF 
+{"document": $LOG_ENTRY, "options": $CONTROLLER_PROOF_OPTIONS}
+EOF
+)
+```
\ No newline at end of file
diff --git a/demo/register.sh b/demo/register.sh
new file mode 100755
index 0000000..12a97fd
--- /dev/null
+++ b/demo/register.sh
@@ -0,0 +1,79 @@
+#! /bin/bash
+
+DID_REQUEST=$(curl -H Host:server.docker.localhost \
+    'http://127.0.0.1?namespace=demo&identifier=issuer' | jq .)
+
+DID_DOCUMENT=$(echo $DID_REQUEST | jq .didDocument)
+PROOF_OPTIONS=$(echo $DID_REQUEST | jq .proofOptions)
+UPDATE_KEY=$(curl -X 'POST' -H Host:agent.docker.localhost \
+  'http://127.0.0.1/wallet/keys' \
+  -d '{}' | jq -r .multikey)
+CONTROLLER_VERIFICATION_METHOD="did:key:$UPDATE_KEY#$UPDATE_KEY"
+
+# Add verificationMethod to the proof options
+CONTROLLER_PROOF_OPTIONS=$(jq '. += {"verificationMethod": "'"$CONTROLLER_VERIFICATION_METHOD"'"}' <<< "$PROOF_OPTIONS")
+
+# Construct the payload for the request
+PAYLOAD=$(cat <<EOF 
+{"document": $DID_DOCUMENT, "options": $CONTROLLER_PROOF_OPTIONS}
+EOF
+)
+
+# Request a signature on the did document
+SIGNED_DID_DOC=$(curl -X 'POST' -H Host:agent.docker.localhost \
+  -H 'Content-Type: application/json' \
+  'http://127.0.0.1/vc/di/add-proof' \
+  -d ''"$PAYLOAD"'' | jq .securedDocument)
+
+ENDORSER_KEY='z6MkgKA7yrw5kYSiDuQFcye4bMaJpcfHFry3Bx45pdWh3s8i'
+ENDORSER_VERIFICATION_METHOD="did:key:$ENDORSER_KEY#$ENDORSER_KEY"
+ENDORSER_PROOF_OPTIONS=$(jq '. += {"verificationMethod": "'"$ENDORSER_VERIFICATION_METHOD"'"}' <<< "$PROOF_OPTIONS")
+
+# Construct the payload for the request
+PAYLOAD=$(cat <<EOF 
+{"document": $SIGNED_DID_DOC, "options": $ENDORSER_PROOF_OPTIONS}
+EOF
+)
+
+# Request a signature on the did document
+ENDORSED_DID_DOC=$(curl -X 'POST' -H Host:agent.docker.localhost \
+  -H 'Content-Type: application/json' \
+  'http://127.0.0.1/vc/di/add-proof' \
+  -d ''"$PAYLOAD"'' | jq .securedDocument)
+
+# Construct the payload for the request
+PAYLOAD=$(cat <<EOF 
+{"didDocument": $ENDORSED_DID_DOC}
+EOF
+)
+
+# Request a signature on the did document
+curl -X 'POST' -H Host:server.docker.localhost \
+  -H 'Content-Type: application/json' \
+  'http://127.0.0.1/' \
+  -d ''"$PAYLOAD"'' | jq .
+
+
+curl -H Host:server.docker.localhost http://127.0.0.1/demo/issuer/did.json | jq .
+
+LOG_ENTRY=$(curl -H Host:server.docker.localhost http://127.0.0.1/demo/issuer | jq .logEntry)
+CONTROLLER_PROOF_OPTIONS=$(jq 'del(.challenge)' <<< "$CONTROLLER_PROOF_OPTIONS")
+CONTROLLER_PROOF_OPTIONS=$(jq 'del(.domain)' <<< "$CONTROLLER_PROOF_OPTIONS")
+CONTROLLER_PROOF_OPTIONS=$(jq 'del(.expires)' <<< "$CONTROLLER_PROOF_OPTIONS")
+PAYLOAD=$(cat <<EOF 
+{"document": $LOG_ENTRY, "options": $CONTROLLER_PROOF_OPTIONS}
+EOF
+)
+SIGNED_LOG_ENTRY=$(curl -X 'POST' -H Host:agent.docker.localhost \
+  -H 'Content-Type: application/json' \
+  'http://127.0.0.1/vc/di/add-proof' \
+  -d ''"$PAYLOAD"'' | jq .securedDocument)
+
+PAYLOAD=$(cat <<EOF 
+{"logEntry": $SIGNED_LOG_ENTRY}
+EOF
+)
+curl -X 'POST' -H Host:server.docker.localhost \
+  -H 'Content-Type: application/json' \
+  'http://127.0.0.1/demo/issuer' \
+  -d ''"$PAYLOAD"'' | jq .
diff --git a/server/app/__init__.py b/server/app/__init__.py
index 182bc8b..81c3c00 100644
--- a/server/app/__init__.py
+++ b/server/app/__init__.py
@@ -1,6 +1,6 @@
 from fastapi import FastAPI, APIRouter
 from fastapi.responses import JSONResponse
-from app.routers import identifiers, resolvers
+from app.routers import identifiers
 from config import settings
 
 app = FastAPI(title=settings.PROJECT_TITLE, version=settings.PROJECT_VERSION)
@@ -14,6 +14,5 @@ async def server_status():
 
 
 api_router.include_router(identifiers.router)
-api_router.include_router(resolvers.router)
 
 app.include_router(api_router)
diff --git a/server/app/models/did_document.py b/server/app/models/did_document.py
index ef10869..6849180 100644
--- a/server/app/models/did_document.py
+++ b/server/app/models/did_document.py
@@ -139,4 +139,4 @@ def id_validator(cls, value):
 
 
 class SecuredDidDocument(DidDocument):
-    proof: Union[DataIntegrityProof, List[DataIntegrityProof]] = Field(None)
+    proof: Union[DataIntegrityProof, List[DataIntegrityProof]] = Field()
diff --git a/server/app/routers/identifiers.py b/server/app/routers/identifiers.py
index d658eaf..8f96ab2 100644
--- a/server/app/routers/identifiers.py
+++ b/server/app/routers/identifiers.py
@@ -16,7 +16,8 @@ async def request_did(
     identifier: str = None,
 ):
     if namespace and identifier:
-        did = f"{settings.DID_WEB_BASE}:{namespace}:{identifier}"
+        client_id = f'{namespace}:{identifier}'
+        did = f"{settings.DID_WEB_BASE}:{client_id}"
         await identifier_available(did)
         return JSONResponse(
             status_code=200,
@@ -28,7 +29,7 @@ async def request_did(
             },
         )
 
-    raise HTTPException(status_code=400, detail="Missing request information.")
+    raise HTTPException(status_code=400, detail="Bad Request")
 
 
 @router.post("/")
@@ -43,7 +44,7 @@ async def register_did(
     # Assert proof set
     proof_set = did_document.pop("proof", None)
     if len(proof_set) != 2:
-        raise HTTPException(status_code=400, detail="Expecting proof set.")
+        raise HTTPException(status_code=400, detail="Bad Request")
 
     # Find proof matching endorser
     endorser_proof = next(
@@ -83,23 +84,40 @@ async def register_did(
         initial_log_entry = DidWebVH().create(did_document, authorized_key)
         return JSONResponse(status_code=201, content={"logEntry": initial_log_entry})
 
-    raise HTTPException(status_code=400, detail="Missing expected proof.")
+    raise HTTPException(status_code=400, detail="Bad Request")
 
 
 # DIDWebVH
+@router.get("/{namespace}/{identifier}")
+async def get_log_state(
+    namespace: str,
+    identifier: str
+):
+    client_id = f'{namespace}:{identifier}'
+    log_entry = await AskarStorage().fetch("logEntries", client_id)
+    if not log_entry:
+        did = f"{settings.DID_WEB_BASE}:{client_id}"
+        did_document = await AskarStorage().fetch("didDocument", did)
+        authorized_key = await AskarStorage().fetch("authorizedKey", did)
+        initial_log_entry = DidWebVH().create(did_document, authorized_key)
+        return JSONResponse(status_code=200, content={"logEntry": initial_log_entry})
+    return JSONResponse(status_code=200, content={})
+    
+    
 @router.post("/{namespace}/{identifier}")
 async def create_didwebvh(
     namespace: str,
     identifier: str,
     request_body: RegisterInitialLogEntry,
 ):
+    client_id = f'{namespace}:{identifier}'
     log_entry = request_body.model_dump()["logEntry"]
     did = f"{settings.DID_WEB_BASE}:{namespace}:{identifier}"
 
     # Assert proof set
     proof = log_entry.pop("proof", None)
     if len(proof) != 1:
-        raise HTTPException(status_code=400, detail="Expecting proof.")
+        raise HTTPException(status_code=400, detail="Bad Request")
 
     # Verify proofs
     proof = proof[0]
@@ -108,50 +126,56 @@ async def create_didwebvh(
         authorized_key != await AskarStorage().fetch("authorizedKey", did)
         or authorized_key != log_entry["parameters"]["updateKeys"][0]
     ):
-        raise HTTPException(status_code=400, detail="Key unauthorized.")
+        raise HTTPException(status_code=401, detail="Unauthorized")
 
     AskarVerifier().verify_proof(log_entry, proof)
     log_entry["proof"] = [proof]
-    await AskarStorage().store("logEntries", did, [log_entry])
+    
+    await AskarStorage().store("logEntries", client_id, [log_entry])
+    
     did_document = await AskarStorage().fetch("didDocument", did)
     did_document["alsoKnownAs"] = [log_entry["state"]["id"]]
     await AskarStorage().update("didDocument", did, did_document)
     return JSONResponse(status_code=201, content=log_entry)
 
 
-@router.get("/{namespace}/{identifier}/did.json")
+@router.get("/{namespace}/{identifier}/did.json", include_in_schema=False)
 async def read_did(namespace: str, identifier: str):
     """
     https://identity.foundation/didwebvh/next/#read-resolve
     """
+    client_id = f'{namespace}:{identifier}'
     did = f"{settings.DID_WEB_BASE}:{namespace}:{identifier}"
     did_doc = await AskarStorage().fetch("didDocument", did)
     if did_doc:
         return Response(json.dumps(did_doc), media_type="application/did+ld+json")
-    raise HTTPException(status_code=404, detail="Ressource not found.")
+    raise HTTPException(status_code=404, detail="Not Found")
 
-@router.get("/{namespace}/{identifier}/did.jsonl")
+@router.get("/{namespace}/{identifier}/did.jsonl", include_in_schema=False)
 async def read_did_log(namespace: str, identifier: str):
     """
     https://identity.foundation/didwebvh/next/#read-resolve
     """
-    did = f"{settings.DID_WEB_BASE}:{namespace}:{identifier}"
-    log_entries = await AskarStorage().fetch("logEntries", did)
+    client_id = f'{namespace}:{identifier}'
+    log_entries = await AskarStorage().fetch("logEntries", client_id)
     if log_entries:
         log_entries = "\n".join([json.dumps(log_entry) for log_entry in log_entries])
         return Response(log_entries, media_type="text/jsonl")
-    raise HTTPException(status_code=404, detail="Ressource not found.")
+    raise HTTPException(status_code=404, detail="Not Found")
 
 @router.put("/{namespace}/{identifier}")
 async def update_did(namespace: str, identifier: str, request_body: UpdateLogEntry):
     """
     https://identity.foundation/didwebvh/next/#update-rotate
     """
-    pass
+    client_id = f'{namespace}:{identifier}'
+    raise HTTPException(status_code=501, detail="Not Implemented")
+
 
 @router.delete("/{namespace}/{identifier}")
 async def deactivate_did(namespace: str, identifier: str):
     """
     https://identity.foundation/didwebvh/next/#deactivate-revoke
     """
-    pass
\ No newline at end of file
+    client_id = f'{namespace}:{identifier}'
+    raise HTTPException(status_code=501, detail="Not Implemented")
diff --git a/server/app/routers/resolvers.py b/server/app/routers/resolvers.py
deleted file mode 100644
index e3ae400..0000000
--- a/server/app/routers/resolvers.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from fastapi import APIRouter, HTTPException, Response
-from config import settings
-from app.plugins import AskarStorage
-import json
-
-router = APIRouter(tags=["Resolvers"])
-
-
-@router.get("/{namespace}/{identifier}/did.json", include_in_schema=False)
-async def get_did_document(namespace: str, identifier: str):
-    did = f"{settings.DID_WEB_BASE}:{namespace}:{identifier}"
-    did_doc = await AskarStorage().fetch("didDocument", did)
-    if did_doc:
-        return Response(json.dumps(did_doc), media_type="application/ld+json")
-    raise HTTPException(status_code=404, detail="Ressource not found.")
-
-
-@router.get("/{namespace}/{identifier}/did.jsonl", include_in_schema=False)
-async def get_did_logs(namespace: str, identifier: str):
-    did = f"{settings.DID_WEB_BASE}:{namespace}:{identifier}"
-    log_entries = await AskarStorage().fetch("logEntries", did)
-    if log_entries:
-        log_entries = "\n".join([json.dumps(log_entry) for log_entry in log_entries])
-        return Response(log_entries, media_type="text/jsonl")
-    raise HTTPException(status_code=404, detail="Ressource not found.")
diff --git a/server/pyproject.toml b/server/pyproject.toml
index 6d0d288..e85320c 100644
--- a/server/pyproject.toml
+++ b/server/pyproject.toml
@@ -6,6 +6,7 @@ authors = []
 readme = "../README.md"
 packages = [{ include = "app" }]
 repository = "https://github.com/decentralized-identity/didwebvh-server-py"
+package-mode = false
 
 [tool.poetry.dependencies]
 python = "^3.12"