📘 SDGE eManual

Complete reference for the Sovereign Document Governance Engine — ingestion, verification, workflows, and API.

🏛️ Overview

SDGE (Sovereign Document Governance Engine) is an append-only, hash-chained document ledger designed for Indian Government document governance. It provides tamper-evident storage, ZK receipts, fraud scoring, and a GraphQL-first API for 15 governance domains.

Key properties:

Append-only — documents are never modified or deleted once committed
SHA-256 chained — each block links to the previous block's hash (like a blockchain)
Domain-scoped — all 15 departments have isolated namespaces with domain-specific metadata
Actor-authenticated — every ingest is attributed to a verified government actor
Fraud-scored — every document receives a fraud risk score (0–100) on ingest

Live system: SDGE runs on port 4103 (Bun + Fastify + Mercurius + PostgreSQL 16). The current ledger has — documents across 19 domains — 15 government + 4 cross-border trade (eBL, LC, Charter Party, Freight).

🚀 Quick Start

Go to /login and select your department actor (all demo actors use PIN 1234)
After login, visit /wizard — the 5-step guided document ingest tool
Select your domain, fill document metadata, paste content, review, and confirm
Your document is hashed, assigned a ledger sequence number, and a ZK receipt is issued
Verify any document at any time via the /dashboard → Document Lookup tab

Note: In the current demo, all actors share PIN 1234. Production deployment uses UIDAI-linked biometric or eSign-based authentication.

💡 Core Concepts

Document

A sovereign document is any government-issued record: certificate, order, filing, report, or sensor reading. Each document has a unique docId (UUID), a SHA-256 contentHash, a domain, an actorId, and an ingestTime.

Ledger Entry

When a document is ingested, a ledger entry is created with a monotonically increasing ledgerSeq. Each entry stores the hash of its content plus the prevHash of the prior entry, forming an unbreakable chain.

Fraud Score

Every document is scored 0–100 at ingest time by the SDGE fraud engine. Score interpretation:

0–29 — Low risk (green) — routine document
30–59 — Medium risk (yellow) — review recommended
60–79 — High risk (orange) — manual verification required
80–100 — Critical (red) — flagged for fraud investigation

👤 Actor Roles

Every SDGE operation is performed by an actor — an authenticated government officer. Actors are scoped to their department's domain.

Actor ID	Name	Domain
`actor-land-reg-01`	Land Registry	LAND
`actor-hospital-01`	Civil Hospital	HEALTH
`actor-agri-dept-01`	Agriculture Dept	AGRICULTURE
`actor-gem-01`	GeM Procurement	PROCUREMENT
`actor-cbse-01`	CBSE	EDUCATION
`actor-gst-01`	GST / Supply	SUPPLY_CHAIN
`actor-fcs-01`	FCS / PDS	SUPPLY_CHAIN (PDS)
`actor-discom-01`	DISCOM / IoT	IOT
`actor-gst-dept-01`	Tax Dept (GST)	TAXATION
`actor-uidai-01`	UIDAI / Identity	IDENTITY
`actor-court-01`	District Court	JUDICIARY
`actor-mcd-01`	Municipal Corp	URBAN_LOCAL
`actor-sbi-01`	Bank / Finance	FINANCE
`actor-epfo-01`	EPFO / Labour	LABOUR
`actor-rto-dl-01`	RTO / Transport	TRANSPORT

🔐 Authentication

SDGE uses actor-based PIN authentication in this demo. The session is stored in browser localStorage as sdge_actor — a JSON object with id, name, role, domain, and icon.

// Example session object in localStorage { "id": "actor-land-reg-01", "name": "Land Registry", "role": "District Registrar", "domain": "LAND", "icon": "🏚️" }

The ingest console on the Dashboard checks for this session. If absent, the ingest form is hidden. The wizard also pre-fills the Actor ID from this session.

Security note: This is a demo system. Production SDGE uses UIDAI-authenticated JWT tokens with 4-hour expiry, signed with the department's DSC (Digital Signature Certificate).

🗝️ Sessions

Sessions are browser-local and persist until explicitly cleared. To log out, the session is removed from localStorage. If you clear your browser storage, you will be logged out and redirected to /login.

🗂️ All 15 Governance Domains

SDGE covers all major Indian government document domains. Each domain has its own namespace, auto-classification patterns, and domain-specific metadata fields.

🏚️

LAND

Khasra, mutation certs, e-Nakal, jamabandi

🏥

HEALTH

OPD cards, ABHA records, discharge summaries

🌾

AGRICULTURE

MSP docs, crop insurance, PM-KISAN

📦

PROCUREMENT

GeM POs, tenders, vendor contracts

📚

EDUCATION

CBSE marksheets, certificates, admit cards

🚢

SUPPLY_CHAIN

GST e-way bills, invoices, logistics

🛒

PDS

Ration cards, FCS registers, PDS allocations

📡

IOT

Smart meter data, SCADA logs, sensor reports

🧾

TAXATION

GSTR filings, income tax, PAN records

🪪

IDENTITY

Aadhaar docs, voter ID, DigiLocker

⚖️

JUDICIARY

FIRs, court orders, judgements, summons

🏙️

URBAN_LOCAL

Property tax, building permits, birth/death

🏦

FINANCE

Loan sanction letters, bank statements, KCC

👷

LABOUR

PF passbooks, ESIC, labour contracts

🚗

TRANSPORT

Driving licences, vehicle registration, fitness

📜

EBL

Electronic Bills of Lading — Mari8X · DCSA v3.0 · JNPA/Mundra

🏦

LC_TRADE_FINANCE

SWIFT MT700 Letters of Credit · DeFi escrow auto-settlement

⚓

CHARTER_PARTY

BIMCO voyage/time/bareboat charters · demurrage · COA

🚚

FREIGHT_SETTLEMENT

FreightBox lorry receipts · eWayBill · GPS milestone payments

🤖 Auto-Classification

When you select "Auto-detect domain" in the Wizard or via the GraphQL mutation, SDGE scans the document content for domain-specific signals:

Domain	Signals (regex patterns)
LAND	`khasra`, `khatauni`, `mutation`, `registry`, `e-nakal`
HEALTH	`opd`, `prescription`, `patient`, `discharge`, `abha`
AGRICULTURE	`msp`, `kisan`, `fasal`, `pm-kisan`, `crop insurance`
PROCUREMENT	`gem`, `tender`, `purchase order`, `bid`, `procurement`
EDUCATION	`cbse`, `marksheet`, `result`, `admit card`, `roll number`
TAXATION	`gstin`, `gstr`, `tax invoice`, `pan`, `income tax`
IDENTITY	`aadhaar`, `uid`, `voter id`, `digilocker`
JUDICIARY	`fir`, `court order`, `judgement`, `summons`, `case no`
TRANSPORT	`driving licence`, `dl no`, `rc book`, `vehicle registration`

If no patterns match, the document is classified as UNKNOWN. You can always override the auto-detected domain by selecting one manually.

📥 Ingest Guide

There are three ways to ingest a document:

1. Dashboard Ingest Form

On /dashboard, switch to the Ingest Document tab. You must be logged in. Fill the form and submit — the ledger entry is shown inline.

2. Wizard (Recommended)

The /wizard provides a guided 5-step flow with per-domain metadata fields, auto-detect, a review step, and a formatted ZK receipt on completion. Best for manual document entry.

3. GraphQL Mutation

For programmatic ingest (integrations, batch scripts, workflow automations):

mutation { sdgeIngestDocument(input: { filename: "gstr3b-jul-2025.pdf", actorId: "actor-gst-dept-01", domain: TAXATION, content: "GSTIN: 07AAACR0932J1ZT | Period: Jul 2025 | Tax: ₹2,47,500" }) { docId ledgerSeq fraudScore fraudLevel zkReceiptId contentHash ingestTime } }

🧙 Using the Wizard

The wizard at /wizard walks you through 5 steps:

Select Domain — Choose from 15 domain tiles. Each has an icon, name, and document count badge.
Document Details — Enter filename, verify your actor ID (pre-filled from session), and fill domain-specific fields (e.g., GSTIN for TAXATION, Case No. for JUDICIARY).
Paste Content — Enter the document text. Optionally enable Auto-detect domain to re-classify based on content.
Review — A summary panel shows all fields before commit. Confirm or go back to edit.
Receipt — After successful ingest, a formatted ZK receipt is displayed with docId, ledgerSeq, contentHash, fraud score, and a sharable receipt ID.

📦 Bulk Ingest

For batch ingestion, use the /workflows automation page. Each workflow can ingest multiple documents in a single run. Alternatively, use the GraphQL mutation in a loop from your backend service.

// Node.js / Bun batch example const docs = ["doc1 content", "doc2 content"]; for (const content of docs) { await fetch('https://sdge.ankrlabs.org/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ query: `mutation { sdgeIngestDocument(input:{ filename:"batch.dat", actorId:"actor-land-reg-01", domain: LAND, content:"${content}" }) { docId ledgerSeq } }` }) }); }

🔗 Sovereign Ledger

The SDGE ledger is an in-memory, append-only chain. Each entry has:

Field	Type	Description
`ledgerSeq`	number	Monotonically increasing sequence number
`docId`	UUID	Unique document identifier
`contentHash`	SHA-256 hex	Hash of filename+actorId+domain+content
`prevHash`	SHA-256 hex	Hash of the previous ledger entry
`ingestTime`	ISO timestamp	UTC timestamp of ingest
`fraudScore`	0–100	Fraud risk score at ingest time
`zkReceiptId`	UUID	Zero-knowledge proof receipt identifier

Persistence: SDGE uses PostgreSQL 16 (ankr_sdge, port 5437) as its ledger store. The append-only guarantee is enforced at the DB level — CREATE RULE blocks all UPDATE and DELETE on sdge_ledger. 6 tables: sdge_ledger, sdge_documents, sdge_fraud_signals, sdge_actors, sdge_ebl_registry, sdge_freight_events.

✅ Chain Verification

Use the Verify Chain tab on the Dashboard to check the integrity of any document or the entire chain:

query { sdgeVerifyChain { chainLength isValid lastHash brokenAt } } // Or verify a single document by docId: query { sdgeLookupDoc(docId: "<uuid>") { docId contentHash ledgerSeq fraudScore fraudLevel ingestTime } }

🔏 ZK Receipts

Every successful ingest issues a Zero-Knowledge Receipt — a UUID that can be shared publicly to prove a document was committed to the chain at a specific time, without revealing the document content itself.

The ZK receipt ID is derived from the contentHash and ledgerSeq. It can be verified by anyone with access to the SDGE API:

query { sdgeLookupReceipt(receiptId: "<zkReceiptId>") { valid docId domain ingestTime ledgerSeq } }

📐 GraphQL Schema

All SDGE operations are exposed via a single GraphQL endpoint: POST https://sdge.ankrlabs.org/graphql

type SdgeDocument { docId: String! filename: String! actorId: String! domain: DocumentDomain! contentHash: String! ledgerSeq: Int! fraudScore: Int! fraudLevel: String! zkReceiptId: String! ingestTime: String! } enum DocumentDomain { LAND HEALTH AGRICULTURE PROCUREMENT EDUCATION SUPPLY_CHAIN IOT PDS TAXATION IDENTITY EBL LC_TRADE_FINANCE CHARTER_PARTY FREIGHT_SETTLEMENT JUDICIARY URBAN_LOCAL FINANCE LABOUR TRANSPORT UNKNOWN }

🔎 Queries

Query	Auth	Description
`sdgeStats`	Public	totalDocs, ledgerSeq, chainHealth, onlineSince
`sdgeLookupDoc(docId)`	Public	Fetch document by docId
`sdgeListDocs(domain?, limit, offset)`	Actor	List documents, optionally filtered by domain
`sdgeVerifyChain`	Public	Verify full chain integrity
`sdgeDomainStats`	Public	Per-domain document counts
`sdgeLookupReceipt(receiptId)`	Public	Verify a ZK receipt

✏️ Mutations

Mutation	Auth	Description
`sdgeIngestDocument(input)`	Actor	Ingest a document — returns full ledger entry with ZK receipt

Input fields for `sdgeIngestDocument`

Field	Required	Description
`filename`	✓	Original filename of the document
`actorId`	✓	Authenticated actor ID (e.g. `actor-land-reg-01`)
`domain`	✓	DocumentDomain enum value
`content`	✓	Full text content of the document to be hashed and stored

⚙️ Automation Guide

The /workflows page provides 11 pre-built automation workflows across 4 categories:

Ingest Automations — Bulk, scheduled pulls from source APIs (LRC, GSTN, NHA, GeM)
Verification & Audit — Chain integrity scan, fraud pipeline, identity dedup, IoT sweep
Reporting & Export — Daily digest, court approval flow, municipal consolidation

Each workflow can be triggered on-demand, scheduled (hourly/daily/weekly), or chained. Schedule state is stored in the session and persists in localStorage.

Production: In a production deployment, workflows are managed by the @ankr/workflow-engine package — a cron-backed orchestrator with webhook triggers, retry logic, and audit log persistence.

🕵️ Fraud Detection

The SDGE fraud scoring engine runs on every ingest. It evaluates several signals:

Content entropy — random or garbled content scores higher
Actor domain mismatch — a HEALTH actor ingesting LAND documents is flagged
Duplicate content hash — exact duplicates score 100 (blocked)
Known fraud patterns — regex matches for forged Aadhaar numbers, fake GSTINs
Temporal anomalies — document dated in the future or >10 years old

To run a full fraud investigation across all high-risk documents, use the Fraud Investigation Pipeline workflow.