Citizen Health Data Wallet: Decentralized, Privacy-Preserving Health Record Sharing Platform

Deep-Dive into the Technical Underpinnings of a Privacy-Preserving Health Data Wallet: A Comparative Engineering Analysis

The concept of a decentralized health data wallet, while conceptually aligned with patient autonomy, presents a formidable set of engineering challenges that must be solved at the foundational level. Unlike centralized Electronic Health Record (EHR) systems where a single entity manages access control, a citizen-held data wallet requires a distributed architecture that enforces privacy, data integrity, and interoperability without a central point of control or failure. This technical deep-dive focuses on the immutable engineering principles governing such a system, analyzing the specific architectural choices, cryptographic primitives, and failure modes that define a viable production-grade solution. We will explore how systems must be designed to handle the complex interplay between selective disclosure, auditability, and high-availability health data access, leveraging Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/) as a foundational enabler for secure, compliant, and scalable distributed data platforms.

Cryptographic Backplane: Verifiable Credentials and Zero-Knowledge Proofs for Selective Disclosure

The core challenge is not merely encrypting data, but enabling a patient to prove an attribute (e.g., "I am over 18" or "My A1C level is below 7.0") without revealing the underlying data value. This requires a shift from traditional Public Key Infrastructure (PKI) to a Verifiable Credential (VC) and Zero-Knowledge Proof (ZKP) architecture.

| Feature | Traditional PKI (X.509) | Decentralized VC + ZKP (e.g., BBS+ Signatures) | | :--- | :--- | :--- | | Core Object | Certificate binding a public key to an identity. | Verifiable Credential signed by an issuer, held by a holder. | | Disclosure Model | Full disclosure of the certificate's attributes. | Selective disclosure of attributes via ZKP. | | Correlation Risk | High. Every presentation of the certificate reveals the same identifier. | Low. The prover can generate a unique, unlinkable proof per session. | | Revocation | Certificate Revocation Lists (CRLs) or OCSP. | Anoncreds revocation registry (accumulators) or status list 2021. | | Data Minimization | Low (all or nothing). | High (minimum necessary data revealed). |

System Inputs/Outputs and Failure Modes:

• Input (Issuance): A healthcare provider's issuing agent creates a VC for a patient (e.g., {"type": ["VerifiableCredential", "HealthConditionCredential"], "credentialSubject": {"id": "did:example:patient123", "condition": "Asthma", "severity": "Moderate", "medication": "Albuterol"}}). This VC is signed using a BBS+ signature suite.
• Output (Verification): A pharmacist requests proof of an active prescription for Albuterol. The patient's wallet generates a ZKP that proves the medication field matches Albuterol and the condition is Asthma, without revealing the severity or any unique identifier from the VC. The output is a zero-knowledge proof object, not the raw credential.
• Failure Mode 1: Signature Aggregation Overflow. If a wallet stores thousands of VCs and attempts to generate a proof across multiple credentials, the computational load on a mobile device can become prohibitive. Mitigation: Use segmented storage and indexed ZKP circuits. The wallet must pre-compute and cache verification keys and partial proofs for high-frequency credential types. Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/) provide a backend for efficient key management and proof-request validation, offloading heavy cryptographic lifting from the client.
• Failure Mode 2: Revocation Window Lag. A prescription is canceled, but the revocation list is not updated synchronously. A patient could generate a valid ZKP after the revocation takes effect. Mitigation: Implement an Online Status Check (dIDComm-based, real-time) for high-stakes attributes like active prescriptions or vaccination status. The verifier must check a tamper-evident log (e.g., a Bitcoin timestamped Merkle tree) or a dedicated registry endpoint.

Decentralized Identifier (DID) Resolution and Key Management for Resilient Offline Operation

The wallet's core identity is rooted in a DID, which must be resolvable to a DID Document containing public keys and service endpoints. However, a health data wallet must function reliably even when internet connectivity is intermittent (e.g., in a rural clinic or during a disaster).

Comparative Engineering Stacks: DID Methods

| DID Method | Registry Type | Key Rotation | Offline Capability | Use Case for Health Wallet | | :--- | :--- | :--- | :--- | :--- | | did:key | None (Embedded) | Impossible (self-certifying) | Full (included in connection) | Ephemeral, single-use connections. | | did:peer | Peer-to-Peer (p2p) | Manual | Full (shared over p2p channel) | Direct clinician-patient pairwise relationships. | | did:webs | Web Domain (HTTPS) | Standard | None (requires DNS/web) | Public health authority directories. | | did:ethr (or did:indy) | Public Blockchain | On-chain transaction | Partial (resolution requires local node or trusted gateway) | High-integrity, globally immutable audit logs. |

Architecture Blueprint for Offline and High-Security Zones:

The wallet architecture must implement a dual-DID strategy:

1. Long-lived did:key or did:peer: Stored locally on the device. Used for biometric unlock and local encryption of the credential storage envelope. This DID has no on-chain footprint, maximizing privacy.
2. Network-Aware did:indy: Used for interactions with centralized healthcare systems (hospitals, insurers, national health services). The DID Document on the blockchain lists an Authorization Key (used for signing consent receipts and audit entries). This key must be rotated every 90 days to mitigate the risk of long-term key compromise.

System Inputs/Outputs and Failure Modes:

• Input (Resolution Request): A hospital's system requests the patient's DID Document to verify a consent signature. Input: did:indy:2:mainnet:12345abcdef.
• Output (DID Document): A JSON-LD object containing verificationMethod (two public keys: one for authentication, one for assertion), serviceEndpoint (URL for the patient's cloud backup agent), and alsoKnownAs (DID linked to a national health identifier).
• Failure Mode 1: Blockchain Re-organization. A short-lived fork on the underlying ledger could cause the DID Document to temporarily resolve to an old, compromised key. Mitigation: The verifier must wait for n confirmations (e.g., 6 block confirmations on the underlying Indy or Ethereum network) before accepting a key. Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/) can act as a relay node that monitors the blockchain's finality, queuing requests until the risk of re-org passes.
• Failure Mode 2: Biometric Key Vault Corruption. The operating system's Trusted Execution Environment (TEE) or Secure Enclave fails, locking the user out of their wallet and all private keys. Mitigation: Implement Social Recovery or Hardware Security Module (HSM) Sharding. The private key for the did:peer identity is sharded using Shamir's Secret Sharing (SSS). Two of three shards are held by pre-designated guardians (a family member, a legal representative, and an institutional HSM managed via Intelligent-Ps SaaS Solutions). On device failure, the wallet can be restored using the shards.

Data Storage Envelope and Synchronization Protocol: Conflict-Free Replicated Data Types (CRDTs) for Medical Records

A citizen's health data wallet is not a single database; it is a distributed state machine where the local device (phone) and a cloud backup agent must remain synchronized. Standard CRUD (Create, Read, Update, Delete) operations are insufficient because they require a single source of truth. Conflict-Free Replicated Data Types (CRDTs) offer a mathematically deterministic approach to merging concurrent updates.

Comparative Database Systems

| Feature | Traditional SQL (PostgreSQL) | Document DB (MongoDB) | CRDT-based Store (Automerge/Yjs) | | :--- | :--- | :--- | :--- | | Consistency Model | Strong (ACID) | Eventual | Strong Eventual (no conflicts) | | Concurrency Handling | Pessimistic (Locks) | Last Write Wins (LWW) | Merged automatically | | Offline Editing | Not supported natively | Partial (conflicts) | Full support | | Data Model | Schema-on-write | Schema-on-read | Schema-agnostic, document-based |

The storage envelope must be a semi-structured JSON object representing the entire user's record library (e.g., {"vaccinations": [...], "lab_results": [...], "medications": [...]}). Each field within a sub-array is a CRDT.

System Inputs/Outputs and Failure Modes:

• Input (Local Operation): Patient logs a new blood pressure reading {"timestamp": "2024-05-15T14:00:00Z", "systolic": 120, "diastolic": 80}. The CRDT library creates a unique ID (lamport_timestamp, device_id) for the new object and inserts it into the vitals array.
• Output (Synchronization): The wallet syncs with the cloud agent. The input is a "change set" consisting of the mutated structure. The output on the cloud agent is a merged version of the CRDT document that is mathematically guaranteed to be identical to the local version after all operations are applied.
• Failure Mode 1: Amnesia of a Device. A device performs a factory reset, losing its unique CRDT identifier. The cloud agent may still hold the authoritative "merged" state. Mitigation: The cloud agent acts as a Reference Node. The restored wallet must perform a full state pull, replacing its local CRDT history with the cloud agent's current state. The cloud agent's state is itself a CRDT that has been globally merged.
• Failure Mode 2: Malicious Data Poisoning. An attacker gains access to a device and inserts false lab results. Mitigation: Every operation in the CRDT change set must be digitally signed with the device's private key. The cloud agent verifies the signature of every incoming operation before merging it into the global state. This creates an immutable audit trail of who changed what and when. Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/) provides a scalable signing and verification middleware that can process millions of CRDT operations per hour, ensuring data integrity without compromising sync speed.

Configuration Template for a Mobile Health Wallet Agent (Docker Compose)

This configuration outlines the microservices required for a production-ready wallet backend, excluding the mobile client itself. It integrates a cloud agent (for sync), a DID resolver, and a ZKP verifier service.

version: '3.8'

services:
  cloud-agent:
    image: intps/cloud-wallet-agent:latest # Hyperledger Aries Cloud Agent Python (ACA-Py) based
    container_name: health-wallet-sync
    environment:
      - AGENT_ENDPOINT=${PUBLIC_AGENT_URL}
      - WALLET_TYPE=indy
      - WALLET_STORAGE_CONFIG={"url":"postgres://user:pass@wallet-db:5432/agent_wallet"}
      - GENESIS_URL=${NETWORK_GENESIS_URL} # URL of the blockchain genesis file
      - AUTO_ACCEPT_INVITES=true
      - AUTO_ACCEPT_REQUESTS=true
      - LOG_LEVEL=info
    ports:
      - "8080:8080" # HTTP API
      - "8020-8029:8020-8029" # Inbound DIDComm ports
    depends_on:
      - wallet-db
      - did-resolver
    volumes:
      - ./config/agent_yml:/home/indy/.indy_client/wallet # Mount for wallet seed or config
    restart: unless-stopped

  wallet-db:
    image: postgres:15
    container_name: wallet-pg
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: agent_wallet
    volumes:
      - wallet-pg-data:/var/lib/postgresql/data
    restart: unless-stopped

  did-resolver:
    image: intps/universal-resolver:latest
    container_name: did-resolver-service
    environment:
      - UNIRESOLVER_DRIVER_INDY_ENABLED=true
      - UNIRESOLVER_DRIVER_ETH_ENABLED=false
      - UNIRESOLVER_DRIVER_KEY_ENABLED=true
    ports:
      - "8081:8080" # HTTP API for DID resolution
    restart: unless-stopped

  zkp-verifier:
    image: intps/anoncreds-rs-verifier:latest
    container_name: zkp-engine
    environment:
      - VERIFIER_DATABASE_URL=sqlite:///tmp/verifier_db.sqlite
      - REVOCATION_REGISTRY_URL=${PUBLIC_REVOCATION_REGISTRY}
    ports:
      - "8082:8080" # Accepts proof request templates, returns verification result
    depends_on:
      - did-resolver
    restart: unless-stopped

  health-data-backup:
    image: intps/crdt-sync-server:latest
    container_name: crdt-backup
    environment:
      - CRDT_USER_DIR=/data/users
      - SYNC_TOKEN_SECRET=${SYNC_SECRET_KEY}
    ports:
      - "8083:8080"
    volumes:
      - crdt-backup-data:/data
    depends_on:
      - cloud-agent # To handle authentication tokens
    restart: unless-stopped

volumes:
  wallet-pg-data:
  crdt-backup-data:

Configuration Analysis: This stack separates concerns cleanly. The cloud-agent handles all DIDComm messaging and credential issuance/presentation. The zkp-verifier is a dedicated service for verifying zero-knowledge proofs, ensuring the cryptographic load does not impact messaging throughput. The health-data-backup service syncs the large unstructured CRDT data. This modular design, achievable with Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/), allows independent scaling of each component based on load (e.g., scaling ZKP verifiers during flu season when vaccine status verification spikes).

JSON Schema for a Consent Receipt (Audit Log Entry)

Every access to a patient's data wallet must result in an immutable log entry, signed by both the patient's wallet and the requesting entity. This is a core output of the system.

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "HealthDataConsentReceipt",
  "type": "object",
  "properties": {
    "receiptId": {
      "type": "string",
      "description": "Globally unique identifier for the consent event."
    },
    "patientDID": {
      "type": "string",
      "pattern": "^did:(key|indy|peer):[a-zA-Z0-9]+$"
    },
    "requesterDID": {
      "type": "string",
      "pattern": "^did:(key|indy|peer):[a-zA-Z0-9]+$"
    },
    "requestTimestamp": {
      "type": "string",
      "format": "date-time",
      "description": "Time the request was made from the verifier."
    },
    "consentTimestamp": {
      "type": "string",
      "format": "date-time",
      "description": "Time the patient approved the request."
    },
    "scopeOfRequest": {
      "type": "object",
      "properties": {
        "attributesRequested": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": ["givenName", "familyName", "dateOfBirth", "bloodType", "a1cLevel", "vaccinationStatus", "medicationList"]
          }
        },
        "purposeOfUse": {
          "type": "string",
          "enum": ["TREATMENT", "PAYMENT", "HEALTHCARE_OPERATIONS", "PUBLIC_HEALTH", "RESEARCH"]
        }
      },
      "required": ["attributesRequested", "purposeOfUse"]
    },
    "proofs": {
      "type": "object",
      "properties": {
        "patientSignature": {
          "type": "string",
          "description": "JWT from the patient's wallet, proving consent."
        },
        "verifierChallenge": {
          "type": "string",
          "description": "Nonce provided by verifier to prevent replay."
        }
      },
      "required": ["patientSignature", "verifierChallenge"]
    }
  },
  "required": ["receiptId", "patientDID", "requesterDID", "requestTimestamp", "consentTimestamp", "scopeOfRequest", "proofs"]
}

Failure Mode: Receipt Replay Attack. An attacker intercepts a receipt and tries to re-use it to prove consent for a different data request. Mitigation: The verifierChallenge field is a one-time-use nonce. The Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/) audit engine maintains a registry of consumed nonces, rejecting any receipt with a duplicate challenge. The receipt itself is hashed and anchored to a distributed ledger, providing a tamper-evident record that the consent occurred at a specific point in time, for a specific purpose.

Conclusion of Static Technical Principles

The architecture for a Citizen Health Data Wallet is not about a single application but a complex, decentralized system of cryptographic backplanes, conflict-free data structures, and modular microservices. The core engineering principles—selective disclosure via ZKPs, offline resilience via peer DIDs, conflict-free merging via CRDTs, and non-repudiation via signed receipts—are the immutable foundations on which any viable system must be built. The failure modes are not theoretical; they are the vectors for privacy breaches, data loss, and system compromise. A production-grade solution must rigorously enforce these technical guardrails, utilizing a robust SaaS infrastructure like Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/) to handle the operational complexities of key rotation, CRDT conflict resolution at scale, and high-throughput ZKP verification against revocation registries.