GDPR and Blockchain: How Hash-Only Mode Enables True Data Sovereignty

TRADITIONAL (GDPR PROBLEMATIC):
┌──────────────┐     ┌──────────────┐
│   Your App   │────▶│  Blockchain  │
│              │     │  (Personal   │
│  Personal    │     │    Data!)    │  ← Cannot delete!
│    Data      │     └──────────────┘
└──────────────┘

HASH-ONLY MODE (GDPR COMPLIANT):
┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   Your App   │────▶│              │────▶│  Blockchain  │
│              │     │   Anchora    │     │              │
│  Personal    │     │  (Hash only) │     │  (Hash only) │ ← Just random characters
│    Data      │     └──────────────┘     └──────────────┘
└──────┬───────┘
       │
       ▼ DELETE request
┌──────────────┐
│   Deleted!   │  ← Right to erasure satisfied
│  (Hash now   │
│  meaningless)│
└──────────────┘

import VaaS from '@anchora/sdk';

const vaas = new VaaS({
  apiKey: process.env.ANCHORA_API_KEY
});

// CREATE: Anchor user data with hash-only mode
async function createUserRecord(userData) {
  // Anchor ONLY the hash (no data sent to Anchora)
  const result = await vaas.anchor({
    data: userData,
    hashOnly: true  // ← GDPR-compliant mode
  });

  // Store in YOUR database (you control deletion)
  await db.users.create({
    ...userData,
    verification: {
      hash: result.hash,
      recordId: result.recordId
    }
  });

  return result;
}

// DELETE: Handle right to erasure request
async function handleErasureRequest(userId) {
  // Get the user record
  const user = await db.users.findById(userId);

  // Delete personal data from YOUR database
  await db.users.delete(userId);

  // Log the erasure for compliance audit
  await db.erasureLogs.create({
    userId,
    erasedAt: new Date(),
    orphanedHash: user.verification.hash
    // Note: We log the hash for audit purposes
    // It's meaningless without the original data
  });

  return {
    success: true,
    message: 'Personal data erased. Blockchain hash orphaned.'
  };

  // The hash on blockchain is now MEANINGLESS:
  // - Cannot be reversed to reveal data
  // - Cannot be linked to the individual
  // - No longer "relates to" an identified person
}

const vaas = new VaaS({
  apiKey: process.env.ANCHORA_API_KEY,
  mode: 'maximum'  // Self-sovereign mode
});

// YOU handle everything locally
const hash = vaas.computeHash(personalData);  // Local
const tree = vaas.buildMerkleTree(hashes);     // Local

// Send ONLY the Merkle root to Anchora
const result = await vaas.anchorRoot({
  merkleRoot: tree.root
});

// Anchora receives: "0x9876543210fedcba..."
// That's it. No hashes. No data. Just a 32-byte root.

// Verification happens LOCALLY (no Anchora needed!)
const isValid = vaas.verifyProof({
  hash: hash,
  proof: merkleProof,
  root: tree.root
});

async function rectifyData(userId, corrections) {
  // Get current record
  const user = await db.users.findById(userId);

  // Create corrected data
  const correctedData = {
    ...user,
    ...corrections,
    rectifiedAt: new Date().toISOString(),
    previousHash: user.verification.hash  // Audit trail
  };

  // Create new anchor for corrected data
  const result = await vaas.anchor({
    data: correctedData,
    hashOnly: true
  });

  // Update database
  await db.users.update(userId, {
    ...corrections,
    verification: {
      hash: result.hash,
      recordId: result.recordId,
      version: user.verification.version + 1
    }
  });

  return result;
}

async function handleAccessRequest(userId) {
  const user = await db.users.findById(userId);

  // Get blockchain proof
  const proof = await vaas.getProof(user.verification.hash);

  return {
    // All personal data held
    personalData: {
      name: user.name,
      email: user.email,
      // ... other fields
    },

    // Verification proof (bonus: proves data integrity!)
    integrityProof: {
      hash: user.verification.hash,
      anchoredAt: proof.anchoredAt,
      blockNumber: proof.blockNumber,
      verificationUrl: `https://polygonscan.com/tx/${proof.transactionHash}`
    },

    // Processing information
    processingInfo: {
      purpose: 'Account management and integrity verification',
      legalBasis: 'Contract performance (Article 6(1)(b))',
      retention: 'Until account deletion or 7 years post-termination'
    }
  };
}

async function exportUserData(userId) {
  const user = await db.users.findById(userId);
  const proof = await vaas.getProof(user.verification.hash);

  // Export in machine-readable format (JSON)
  return {
    exportedAt: new Date().toISOString(),
    format: 'application/json',

    // User data
    data: user,

    // Blockchain verification (unique to Anchora!)
    // The receiving service can VERIFY this data is authentic
    verification: {
      hash: proof.hash,
      merkleProof: proof.merkleProof,
      blockNumber: proof.blockNumber,
      network: 'polygon',
      instructions: 'Verify at https://verify.anchora.io'
    }
  };
}

DATA INTEGRITY VERIFICATION

We use blockchain-based verification to ensure the integrity of
your data. This process works as follows:

1. When you create or update your data, we generate a cryptographic
   "fingerprint" (hash) of that data using SHA-256 encryption.

2. This hash is a one-way mathematical function - it cannot be
   reversed to reveal your actual data.

3. The hash is anchored to the Polygon blockchain, creating an
   immutable timestamp and proof of integrity.

4. Your actual personal data is stored only in our secure database,
   which you can request to be deleted at any time.

IMPORTANT: If you exercise your right to erasure (deletion), we will
delete your personal data from our systems. The hash on the blockchain
will become "orphaned" - it will be a meaningless string of characters
that cannot be linked back to you or reveal any information about you.

This approach allows us to provide tamper-proof verification while
fully respecting your privacy rights under GDPR.