Date Seal: A Peer-to-Peer, Local-First, Self-Verifiable Document Integrity System

By Josh Spooner and contributors DRAFT 6 - August 2024

Satoshi Nakamoto

In the digital realm, a visionary’s spark ignited, Satoshi’s genius, both in code and narrative, united. A chain of trust, decentralized and bright, your legacy forever recited.

Abstract (open Abstract callout to read, or jump to the demo to see it in action markdown)

Abstract

Date Seal is a protocol that provides human-verifiable proof of a content block’s existence at a specific point in time, as easy to use as copy-paste. This local-first, tamper-proof, and self-verifiable document format empowers users with cost-effective, trustworthy, tamper-verifiable record-keeping and dynamic accounting ledgers. By standardizing the deformatting, digestion, time-stamping, and updating of content blocks with canonical, content-addressable links, Date Seal bridges a gap between smart contracts and human-readable, local-first Ricardian contracts and the larger gap between cloud and local-first architectures. ✉️

1. Introduction

Key Concept

Date Seal offers a paradigm shift in establishing trust in digital documents, empowering end-users own their own devices with the tools to verify cryptographic proofs of contents uniqueness and existence in time via a chain of timestamps.

Ina an era where digital content integrity is paramount, Date Seal introduces a revolutionary approach to document verification. This paper presents the core components of the Date Seal system: namely, markdown content blocks with links and the commands to Digest, Seal, and Copy-Check content blocks. These components work in concert to create a robust, decentralized system for content and timestamp verification.

By leveraging the power of cryptographic proofs and decentralized verification, Date Seal aims to revolutionize how we establish trust in digital documents, paving the way for more secure, transparent, and user-controlled data management in the digital age. ✉️

Date Seal

Date Seal is a protocol the empowers anyone on their own device to simply make Content Blocks tamper-verifiable (as easy as copy-paste on a desktop) by using the Digest Command, Seal Command, and Copy-Check Command to create Markdown Links that include the necessary metadata to verify content existed at a point in time and is unaltered.

Granularity: Date Seal allows for verification at various levels of document granularity, from entire sections to individual paragraphs or list items.
Flexibility: The protocol adapts to different content types, making it versatile for various document formats and styles.
Non-intrusive: The seal format is designed to be unobtrusive, preserving document readability while providing cryptographic assurance.
Version Control: By sealing individual blocks, Date Seal facilitates fine-grained version control and change tracking.
Interoperability: The markdown-compatible format ensures that Date Seal can work alongside existing document workflows and tools. ✉️

Content Blocks

A content block is a discrete unit of information in a markdown document or folder that can be individually referenced, linked, sealed, and verified. Key characteristics include:

Structural Boundaries: Delineated by elements such as:
- Headers (e.g., # Header 1, ## Header 2)
- Blank lines separating paragraphs
- List items (bulleted or numbered)
- Code blocks (fenced or indented)
- Callouts (toggle-able)
- Blockquotes
Semantic Unity: Represents a cohesive unit of information.
Deformat-able: Ability to extract core content by removing markdown syntax.
Granularity: Size can vary based on document needs.
Nestability: Can be nested within each other.
Metadata Inclusion: May include its own metadata. ✉️

Markdown Links

Date Seal can leverage various types of Markdown links for references and embeds. Although many of this link formats could be used, this Smart Paper implements and demos Date Seal using the Footnote Link and Block ID.

Link Type	Syntax	Purpose	Example
Standard Web Link	`[text](URL)`	Creates a clickable link to a web page	`[WikiWe](https://www.wikiwe.org)`
Internal Link	`[[]]`	Links to another note within the system	`[[Project Overview]]`
Embed	`![[ ]]`	Embeds content from another note or media file	`![[Monthly Report.pdf]]`
Block Reference	`[[\#^]]`	Links to a specific block or heading in another note	`[[Meeting Notes\#^action-items]]`
Footnote Link	`[^]`	Creates a reference to a footnote	`This is a fact[^1]`
Block ID	`^`	Assigns a unique identifier to a block of content	`This is an important point^key-concept`
Image Link	`![alt text](image URL)`	Embeds an image from the web	`![Logo](https://example.com/logo.png)`

Digest Command

The Digest Command is the initial step in the Date Seal process, creating a unique cryptographic hash of a content block with a timestamp, called a Digest Link.

Digest Script Features

Deformats text and tracks removals of formatting elements

Computes a 12-character SHA-256 hash

Handles existing Digest and Seal Links

Creates and updates content digest files

Adds or updates footnotes with digest information

Digest Demo - Text deformatting and digestion demo

Ai-gen Templater Script at Claude Artifact

Sample Implementation - Templater Script: Digest Selected Content Block
[i] Tip: Hotkey as CMD + SHIFT + D with “Hotkeys for templates” Plugin
DS Digest Command 1.4
<%* // Record start time for entire template runtime const startTime = performance.now();

// Import necessary modules const crypto = require(‘crypto’); const fs = require(‘fs’);

// Function to normalize the text block and track removals function normalizeText(block) { console.log([${new Date().toISOString()}] Normalizing text block);
const removals = {
    headers: 0,
    boldItalic: 0,
    unorderedLists: 0,
    orderedLists: 0,
    todos: 0,
    digestLink: 0,
    sealLink: 0
};

// Strip markdown prefixes (e.g., headers, bold, italic)
block = block.replace(/^#+\s+/gm, () => { removals.headers++; return ''; }); // Headers
block = block.replace(/[*_]{1,3}([^*_]+)[*_]{1,3}/g, (_, p1) => { removals.boldItalic++; return p1; }); // Bold and Italics

// Remove ordered lists, lists, and todos
block = block.replace(/^\s*[-*+]\s+/gm, () => { removals.unorderedLists++; return ''; }); // Unordered lists
block = block.replace(/^\s*\d+\.\s+/gm, () => { removals.orderedLists++; return ''; }); // Ordered lists
block = block.replace(/^\s*[-*+]\s+\[.\]\s+/gm, () => { removals.todos++; return ''; }); // Todos

// Remove Digest Link
block = block.replace(/\[\^ds\/[a-f0-9]{12}\/\d{4}-\d{2}-\d{2}\^\]/g, () => { removals.digestLink++; return ''; });

// Remove Seal Link
block = block.replace(/\s\^ds-\d{4}-\d{2}-\d{2}-[a-f0-9]{12}/g, () => { removals.sealLink++; return ''; });

return { normalizedText: block.trim(), removals };
}

// Function to compute a 12-character SHA-256 hash function computeHash(text) { const fullHash = crypto.createHash(‘sha256’).update(text).digest(‘hex’); return fullHash.slice(0, 12); }

// Function to upsert content to a file function upsertToFile(filePath, header, content) { let fileContent = ”; if (fs.existsSync(filePath)) { fileContent = fs.readFileSync(filePath, ‘utf8’); }
const regex = new RegExp(`${header}[\\s\\S]*?(?=###|$)`, 'g');
const replacement = `${header}\n${content}\n\n`;

if (regex.test(fileContent)) {
    fileContent = fileContent.replace(regex, replacement);
} else {
    fileContent += replacement;
}

fs.writeFileSync(filePath, fileContent);
}

// Function to verify if content has already been digested function verifyExistingDigest(content, existingDigest) { const { normalizedText } = normalizeText(content); const computedDigest = computeHash(normalizedText); return computedDigest === existingDigest; }

// Get the currently selected text in Obsidian console.log([${new Date().toISOString()}] Getting selected text); let selection = app.workspace.activeEditor.getSelection();

// Check if no text is selected if (!selection || selection.trim() === ”) { const noSelectionError = “No text selected. Please select the text you want to digest.”; new Notice(noSelectionError); console.error([${new Date().toISOString()}] ${noSelectionError}); throw new Error(noSelectionError); }

// Check for existing Digest Links and Seal Links const digestLinkMatches = […selection.matchAll(/[^ds/([a-f0-9]{12})/(\d{4}-\d{2}-\d{2})^]/g)]; const sealLinkMatches = […selection.matchAll(/\s(^ds-(\d{4}-\d{2}-\d{2})-([a-f0-9]{12}))/g)];

if (digestLinkMatches.length > 1) { const warningMessage = Warning: Multiple Digest Links found (${digestLinkMatches.length}). Only the last one will be considered.; console.warn([${new Date().toISOString()}] ${warningMessage}); new Notice(warningMessage); }

if (sealLinkMatches.length > 1) { const warningMessage = Warning: Multiple Seal Links found (${sealLinkMatches.length}). Only the last one will be considered.; console.warn([${new Date().toISOString()}] ${warningMessage}); new Notice(warningMessage); }

let existingDigestLink = digestLinkMatches.length > 0 ? digestLinkMatches[digestLinkMatches.length - 1][0] : ”; let existingDigest = digestLinkMatches.length > 0 ? digestLinkMatches[digestLinkMatches.length - 1][1] : ”; let existingDigestDate = digestLinkMatches.length > 0 ? digestLinkMatches[digestLinkMatches.length - 1][2] : ”; let existingSealLink = sealLinkMatches.length > 0 ? sealLinkMatches[sealLinkMatches.length - 1][1] : ”; let existingSealDate = sealLinkMatches.length > 0 ? sealLinkMatches[sealLinkMatches.length - 1][2] : ”; let existingSealHash = sealLinkMatches.length > 0 ? sealLinkMatches[sealLinkMatches.length - 1][3] : ”;

let selectionWithoutLinks = selection; if (existingDigestLink) { selectionWithoutLinks = selectionWithoutLinks.replace(existingDigestLink, ”).trim(); } if (existingSealLink) { selectionWithoutLinks = selectionWithoutLinks.replace(existingSealLink, ”).trim(); }

// Normalize the selected text const { normalizedText: normalizedSelection, removals } = normalizeText(selectionWithoutLinks); console.log([${new Date().toISOString()}] Text normalized); console.log([${new Date().toISOString()}] Normalized Content:\n${normalizedSelection});

// Compute the normal hash of the normalized selection const normalHash = computeHash(normalizedSelection); console.log([${new Date().toISOString()}] Normal Hash computed: ${normalHash});

let digestVerificationResult = ”; if (existingDigestLink) { if (verifyExistingDigest(selectionWithoutLinks, existingDigest)) { const unchangedMessage = “Content unchanged. No re-digestion needed.”; new Notice(unchangedMessage); console.log([${new Date().toISOString()}] ${unchangedMessage}); digestVerificationResult = Existing Digest verified successfully. Date: ${existingDigestDate}; return; } else { digestVerificationResult = “Existing Digest verification failed. Content will be re-digested.”; console.log([${new Date().toISOString()}] ${digestVerificationResult}); } }

// Get the current date in YYYY-MM-DD format const digestDate = new Date().toISOString().split(‘T’)[0]; console.log([${new Date().toISOString()}] Digest date: ${digestDate});

// Calculate word and character counts const wordCount = normalizedSelection.split(/\s+/).length; const charCount = selectionWithoutLinks.length; const lineCount = selectionWithoutLinks.split(‘\n’).length;

// Get additional metadata const currentFile = app.workspace.getActiveFile(); const filePath = currentFile ? currentFile.path : “Unknown”; const frontmatter = app.metadataCache.getFileCache(currentFile).frontmatter; const authors = frontmatter && frontmatter.authors ? frontmatter.authors.join(”, ”) : “Unknown”;

// Ensure the directory exists before writing const digestsContentPath = ${app.vault.adapter.basePath}/Directory/Digests/content/; fs.mkdirSync(digestsContentPath, { recursive: true });

// Append to content digest file const contentDigestPath = ${digestsContentPath}${normalHash}.md; const contentDigestHeader = ### #${normalHash}/${digestDate}; const contentDigestEntry = ${selectionWithoutLinks} #cbc \n${normalizedSelection} #nbc \nFile: ${filePath}\nAuthors: ${authors}; upsertToFile(contentDigestPath, contentDigestHeader, contentDigestEntry); console.log([${new Date().toISOString()}] Upserted to content digest file: ${contentDigestPath});

// Calculate hashtime const endTime = performance.now(); const hashtime = ((endTime - startTime) / 1000).toFixed(6);

// Create the removal summary const removalSummary = Object.entries(removals) .filter(([_, count]) ⇒ count > 0) .map(([type, count]) ⇒ ${type}: ${count}) .join(‘\n’);

// Create the notice and log message const message = `Date Digest v1.5: Normal Hash: $n or ma l H a s h W or d C o u n t :$ {wordCount} Character Count: $c ha r C o u n t L in e C o u n t :$ {lineCount} Normal Character Count: $n or ma l i ze d S e l ec t i o n . l e n g t h R e m o v e d C ha r a c t er C o u n t :$ {charCount - normalizedSelection.length} Hashtime Seconds: $ha s h t im e D i g es t D a t e :$ {digestDate} Digest File: $co n t e n t D i g es tP a t h F i l e P a t h :$ {filePath} Authors: $a u t h ors$ {existingSealLink ? ‘Existing Seal Link preserved: ’ + existingSealLink : ”} ${digestVerificationResult}

Removals during normalization: ${removalSummary}`;

new Notice(message); console.log([${new Date().toISOString()}] Date Digest v1.5: ${message});

// Update the selection with the new digest information const newDigestLink = [^ds/${normalHash}/${digestDate}^]; const updatedSelection = ${selectionWithoutLinks} ${newDigestLink}${existingSealLink ? ' ' + existingSealLink : ''}; app.workspace.activeEditor.editor.replaceSelection(updatedSelection);

// Create the footnote const footnote = [^ds/${normalHash}/${digestDate}^]: ${new Date().toISOString()} WC:${wordCount}, CC:${charCount}, LC:${lineCount}, DF:[[${contentDigestPath.split('/').pop()}]], File: ${filePath}, Authors: ${authors};

// Upsert the footnote under the ”### References” header const fileContent = await app.vault.read(currentFile); let updatedContent = fileContent;

const referencesHeader = ”### References”; const footnoteRegex = new RegExp(\\[\\^ds\\/[a-f0-9]{12}\\/\\d{4}-\\d{2}-\\d{2}\\^\\]:.*, ‘g’);

if (fileContent.includes(referencesHeader)) { const parts = fileContent.split(referencesHeader); if (footnoteRegex.test(parts[1])) { parts[1] = parts[1].replace(footnoteRegex, footnote); } else { parts[1] = \n${footnote}${parts[1]}; } updatedContent = parts.join(referencesHeader); } else { updatedContent += \n\n${referencesHeader}\n${footnote}\n; }

await app.vault.modify(currentFile, updatedContent); console.log([${new Date().toISOString()}] Footnote added or updated under References); %>
Link to original
✉️ ^ds-e56ee1769126

Seal Command

The Seal Command adds a layer of timestamped verification to previously digested content by creating a “Seal Link”.

Seal Features

Verifies existing Digest Link before sealing

Computes a new seal hash

Creates and updates seal digest files

Preserves existing Digest Links and updates Seal Links

Updates footnotes with seal information

Sample Implementation - Templater Script: Seal Selected Content Block
[i] Tip: Hotkey as CMD + SHIFT + S with “Hotkeys for templates” Plugin
DS Seal Command 1.4
<%* // Record start time for entire script runtime const startTime = performance.now();

// Import necessary modules const crypto = require(‘crypto’);

// Function to compute a 12-character SHA-256 hash function computeHash(text) { const fullHash = crypto.createHash(‘sha256’).update(text).digest(‘hex’); return fullHash.slice(0, 12); }

// Function to normalize the text block without modifying the original text function getNormalizedText(block) { // Create a copy of the block to normalize let normalizedBlock = block;
// Strip markdown prefixes (e.g., headers, bold, italic)
normalizedBlock = normalizedBlock.replace(/^#+\s+/gm, ''); // Headers
normalizedBlock = normalizedBlock.replace(/[*_]{1,3}([^*_]+)[*_]{1,3}/g, '$1'); // Bold and Italics

// Remove ordered lists, lists, and todos
normalizedBlock = normalizedBlock.replace(/^\s*[-*+]\s+/gm, ''); // Unordered lists
normalizedBlock = normalizedBlock.replace(/^\s*\d+\.\s+/gm, ''); // Ordered lists
normalizedBlock = normalizedBlock.replace(/^\s*[-*+]\s+\[.\]\s+/gm, ''); // Todos

// Remove Digest Link and Seal Link
normalizedBlock = normalizedBlock.replace(/\[\^ds\/[a-f0-9]{12}\/\d{4}-\d{2}-\d{2}\^\]/g, '');
normalizedBlock = normalizedBlock.replace(/\s\^ds-\d{4}-\d{2}-\d{2}-[a-f0-9]{12}/g, '');

return normalizedBlock.trim();
}

// Function to verify digest function verifyDigest(content, digestHash) { const normalizedContent = getNormalizedText(content); const computedDigest = computeHash(normalizedContent); return computedDigest === digestHash; }

// Function to verify seal function verifySeal(content, sealHash) { const computedSealHash = computeHash(content); return computedSealHash === sealHash; }

// Get the currently selected text in Obsidian console.log([${new Date().toISOString()}] Getting selected text); let selection = app.workspace.activeEditor.getSelection();

// Check if no text is selected if (!selection || selection.trim() === ”) { const noSelectionError = “No text selected. Please select the text you want to verify and copy.”; new Notice(noSelectionError); console.error([${new Date().toISOString()}] ${noSelectionError}); throw new Error(noSelectionError); }

// Calculate text statistics const wordCount = selection.trim().split(/\s+/).length; const charCount = selection.length; const lineCount = selection.split(‘\n’).length;

// Get normalized content const normalizedContent = getNormalizedText(selection);

// Log normalized content console.log([${new Date().toISOString()}] Normalized Content:\n${normalizedContent});

// Check for Digest Links const digestLinkMatches = […selection.matchAll(/[^ds/([a-f0-9]{12})/(\d{4}-\d{2}-\d{2})^]/g)]; let digestVerificationResult = “No Digest Link found.”; if (digestLinkMatches.length > 0) { if (digestLinkMatches.length > 1) { const warningMessage = Warning: Multiple Digest Links found (${digestLinkMatches.length}).; console.warn([${new Date().toISOString()}] ${warningMessage}); new Notice(warningMessage); }
digestVerificationResult = digestLinkMatches.map((match, index) => {
    const [fullDigestLink, digestHash, digestDate] = match;
    console.log(`[${new Date().toISOString()}] Digest Link ${index + 1} found: ${fullDigestLink}`);
    
    if (verifyDigest(selection, digestHash)) {
        return `Digest ${index + 1} verified successfully. Date: ${digestDate}`;
    } else {
        return `Digest ${index + 1} verification failed. Content may have been modified.`;
    }
}).join('\n');
}

// Check for Seal Links const sealLinkMatches = […selection.matchAll(/\s(^ds-(\d{4}-\d{2}-\d{2})-([a-f0-9]{12}))/g)]; let sealVerificationResult = “No Seal Link found.”; if (sealLinkMatches.length > 0) { if (sealLinkMatches.length > 1) { const warningMessage = Warning: Multiple Seal Links found (${sealLinkMatches.length}).; console.warn([${new Date().toISOString()}] ${warningMessage}); new Notice(warningMessage); }
sealVerificationResult = sealLinkMatches.map((match, index) => {
    const [fullSealLink, _, sealDate, sealHash] = match;
    console.log(`[${new Date().toISOString()}] Seal Link ${index + 1} found: ${fullSealLink}`);
    
    const contentWithoutSeal = selection.slice(0, selection.lastIndexOf(fullSealLink)).trim();
    if (verifySeal(contentWithoutSeal, sealHash)) {
        return `Seal ${index + 1} verified successfully. Date: ${sealDate}`;
    } else {
        return `Seal ${index + 1} verification failed. Content may have been modified.`;
    }
}).join('\n');
}

// Calculate verification time const endTime = performance.now(); const verificationTime = ((endTime - startTime) / 1000).toFixed(6);

// Create the verification report const verificationReport = Date Seal 1.5 Verification Report: ${digestVerificationResult} ${sealVerificationResult} Word Count: ${wordCount} Character Count: ${charCount} Line Count: ${lineCount} Verification Time: ${verificationTime} seconds;

// Display the verification report new Notice(verificationReport, 7000); console.log([${new Date().toISOString()}] ${verificationReport});

// Copy the selected text to clipboard without modification await navigator.clipboard.writeText(selection); console.log([${new Date().toISOString()}] Selected text copied to clipboard without modification); new Notice(“Selected text copied to clipboard without modification”);

%>
Link to original
✉️ ^ds-f26c6f0bde1b

Copy-Check Command

The Copy-Check Command provides a non-destructive way to verify the integrity of digested and sealed content.

Copy-Check Features

Verifies both Digest and Seal Links without modifying content

Provides detailed verification report

Logs deformatted content for debugging purposes

Copies verified content to clipboard

Sample Implementation - Templater Script: Copy-Check Selected Content Block
[i] Tip: Hotkey as CMD + SHIFT + C with “Hotkeys for templates” Plugin
DS Copy-Check Command 1.4
<%* // Record start time for entire script runtime const startTime = performance.now();

// Import necessary modules const crypto = require(‘crypto’);

// Function to compute a 12-character SHA-256 hash function computeHash(text) { const fullHash = crypto.createHash(‘sha256’).update(text).digest(‘hex’); return fullHash.slice(0, 12); }

// Function to normalize the text block function normalizeText(block) { // Strip markdown prefixes (e.g., headers, bold, italic) block = block.replace(/^#+\s+/gm, ”); // Headers block = block.replace(/[_]{1,3}([^]+)[*]{1,3}/g, ‘$1’); // Bold and Italics
// Remove ordered lists, lists, and todos
block = block.replace(/^\s*[-*+]\s+/gm, ''); // Unordered lists
block = block.replace(/^\s*\d+\.\s+/gm, ''); // Ordered lists
block = block.replace(/^\s*[-*+]\s+\[.\]\s+/gm, ''); // Todos

// Remove Digest Link and Seal Link
block = block.replace(/\[\^ds\/[a-f0-9]{12}\/\d{4}-\d{2}-\d{2}\^\]/, '');
block = block.replace(/\s\^ds-\d{4}-\d{2}-\d{2}-[a-f0-9]{12}/, '');

return block.trim();
}

// Function to verify digest function verifyDigest(content, digestHash) { const normalizedContent = normalizeText(content); const computedDigest = computeHash(normalizedContent); return computedDigest === digestHash; }

// Function to verify seal function verifySeal(content, sealHash) { const computedSealHash = computeHash(content); return computedSealHash === sealHash; }

// Get the currently selected text in Obsidian console.log([${new Date().toISOString()}] Getting selected text); let selection = app.workspace.activeEditor.getSelection();

// Check if no text is selected if (!selection || selection.trim() === ”) { const noSelectionError = “No text selected. Please select the text you want to verify and copy.”; new Notice(noSelectionError); console.error([${new Date().toISOString()}] ${noSelectionError}); throw new Error(noSelectionError); }

// Check for Digest Link const digestLinkMatch = selection.match(/[^ds/([a-f0-9]{12})/(\d{4}-\d{2}-\d{2})^]/); let digestVerificationResult = “No Digest Link found.”; if (digestLinkMatch) { const [fullDigestLink, digestHash, digestDate] = digestLinkMatch; console.log([${new Date().toISOString()}] Digest Link found: ${fullDigestLink});
if (verifyDigest(selection, digestHash)) {
    digestVerificationResult = `Digest verified successfully. Date: ${digestDate}`;
    console.log(`[${new Date().toISOString()}] ${digestVerificationResult}`);
} else {
    digestVerificationResult = "Digest verification failed. Content may have been modified.";
    console.warn(`[${new Date().toISOString()}] ${digestVerificationResult}`);
}
}

// Check for Seal Link const sealLinkMatch = selection.match(/\s(^ds-(\d{4}-\d{2}-\d{2})-([a-f0-9]{12})) $/); let sealVerificationResult = "No Seal Link found."; if (sealLinkMatch) { const [fullSealLink, _, sealDate, sealHash] = sealLinkMatch; console.log(`[$ {new Date().toISOString()}] Seal Link found: ${fullSealLink}`);
const contentWithoutSeal = selection.replace(fullSealLink, '').trim();
if (verifySeal(contentWithoutSeal, sealHash)) {
    sealVerificationResult = `Seal verified successfully. Date: ${sealDate}`;
    console.log(`[${new Date().toISOString()}] ${sealVerificationResult}`);
} else {
    sealVerificationResult = "Seal verification failed. Content may have been modified.";
    console.warn(`[${new Date().toISOString()}] ${sealVerificationResult}`);
}
}

// Calculate verification time const endTime = performance.now(); const verificationTime = ((endTime - startTime) / 1000).toFixed(6);

// Create the verification report const verificationReport = Date Seal Verification Report: ${digestVerificationResult} ${sealVerificationResult} Verification Time: ${verificationTime} seconds;

// Display the verification report new Notice(verificationReport); console.log([${new Date().toISOString()}] ${verificationReport});

// Copy the selected text to clipboard await navigator.clipboard.writeText(selection); console.log([${new Date().toISOString()}] Selected text copied to clipboard); new Notice(“Selected text copied to clipboard”);

%>
Link to original
✉️ ^ds-bb1b9890a3a8

Command Comparison

An overview of the similarities and differences between the three commands:

Feature	Digest Command	Seal Command	Copy-Check Command
Modifies content	Yes	Yes	No
Creates cryptographic hash	Yes	Yes	No (verifies only)
Requires existing Digest	No	Yes	No (but uses if present)
Adds/Updates footnote	Yes	Yes	No
Creates separate file	Yes (digest)	Yes (seal)	No
Provides verification	For existing digests	Yes	Yes
Handles multiple links	Yes	Yes	Yes
Clipboard interaction	No	No	Yes (copies content)
Content statistics	Yes	Yes	Yes
Deformatted content logging	Yes	Yes	Yes

Implementation Instructions 123

Implementation

Each command is implemented as a script that can be integrated into document editing workflows, using cryptographic functions to ensure content integrity and verifiability. ✉️

Date Seal Syntax

The Date Seal syntax is designed to work within markdown documents:

[^ds/{deformatted-digest}/{YYYY-MM-DD}^] ^ds-{seal-digest}-{YYYY-MM-DD}

Component	Syntax	Example	Explanation
Digest Link	`[^ds/...^]`	`[^ds/a1b2c3d4e5f6/2024-08-19^]`	Primary container for Date Seal information
Seal Link	`^ds-...`	`^ds-g7h8i9j0k1l2-2024-08-19`	Additional reference for linking to specific blocks
Date Seal Identifier	`ds`	`ds`	Prefix indicating Date Seal information
Deformatted Digest	`{deformatted-digest}`	`a1b2c3d4e5f6`	12-character hexadecimal SHA-256 hash of the deformatted content block
Seal Digest	`{seal-digest}`	`g7h8i9j0k1l2`	Hash digest including both deformatted content and Square Caret Block Link for extra verification
Timestamp	`{YYYY-MM-DD}`	`2024-08-19`	Date when the content digested or sealed

This overview combines the markdown elements and Date Seal syntax, providing a comprehensive look at how these components interact within the Date Seal system. ✉️

Incentive ✉️ ^ds-649829878649

Privacy & Security

Date Seal addresses privacy concerns by allowing authors to control or parameterize the inclusion of personal identifiers while separating out formatting contributions from designers, while AI can assists non-technical users in verifying the technical implementation. The security of this system is maintained as long as honest nodes sync periodically and collectively maintain the longest sequence of cross-verified date-sealed blocks, outpacing any potential group of attacker nodes. ✉️

Conclusion

Key Takeaways

The Date Seal system, comprising the Digest, Seal, and Copy-Check Commands, provides a comprehensive solution for content integrity and verification. By leveraging cryptographic proofs and decentralized verification, Date Seal simplifies, localizes, and thus, revolutionizes how we establish trust in digital documents.

The Date Seal system offers a robust mechanism for tracking, verifying, and managing the integrity of content over time:

The Digest Command establishes the initial content fingerprint.
The Seal Command adds a time-stamped verification layer.
The Copy-Check Command allows for non-destructive verification at any point.

Together, these components create a powerful tool for secure, transparent, and user-controlled data management in the digital age. ✉️

WikiWe

Explorer

Date Seal - Smart Paper - DRAFT4

Date Seal: A Peer-to-Peer, Local-First, Self-Verifiable Document Integrity System

1. Introduction

Date Seal

Content Blocks

Markdown Links

Digest Command

DS Digest Command 1.4

Seal Command

DS Seal Command 1.4

Copy-Check Command

DS Copy-Check Command 1.4

Command Comparison

Implementation Instructions 123

Date Seal Syntax

Incentive ✉️ ^ds-649829878649

Privacy & Security

Conclusion

Graph View

Table of Contents