Veilyn Documentation

Veilyn is ZK attestation middleware. It provides reusable proof templates, configurable disclosure policies, and integration-ready verifier packages for privacy-sensitive compliance and onboarding workflows.

Proof Templates

Parameterized attestation blueprints for common selective disclosure scenarios.

Disclosure Policies

Field visibility, trust tiers, expiry rules as auditable policy objects.

Verifier Packages

Everything the receiving party needs to verify — in one deliverable output.

Quickstart

Get a proof configuration running in three steps:

Select a template

Browse the template registry and choose a parameterized attestation blueprint that matches your use case.

GET /api/v1/templates
GET /api/v1/templates/:id

Configure disclosure policy

Define which fields are visible, to whom, under what conditions, and for how long.

POST /api/v1/policies
{
  "template_id": "kyc-basic-v2",
  "fields": {
    "full_name": { "visible": false },
    "age_over_18": { "visible": true },
    "nationality": { "visible": true, "tier": "trusted" }
  },
  "expiry": "30d",
  "trust_tier": "standard"
}

Export verifier package

Generate a verification-ready bundle with metadata, constraints, and integration guidance.

POST /api/v1/verifier-packages
{
  "policy_id": "pol_abc123",
  "format": "standard",
  "include_docs": true
}

Core Concepts

Selective Disclosure

The ability to prove that a claim is true without disclosing the full underlying dataset. Veilyn productizes this capability into a reusable delivery chain.

Proof Packaging

The conversion of proof from a technical primitive into a product delivery format. Templates, policies, and verification outputs become procurable, auditable assets.

Delivery Chain

The sequence of Template → Policy → Verifier that mirrors how organizations make decisions: what must be proven, how much can be disclosed, how verification happens.

Middleware

Veilyn sits between proof generation and proof consumption. It does not generate ZK proofs itself — it packages, governs, and delivers them.

Proof Templates

The template registry manages parameterized attestation patterns. Templates are addressable, versioned, and governable assets — not static files.

Template Structure

{
  "id": "kyc-basic-v2",
  "version": "2.1.0",
  "name": "KYC Basic Attestation",
  "description": "Age and nationality verification without PII exposure",
  "fields": [
    { "name": "full_name", "type": "string", "disclosable": true },
    { "name": "date_of_birth", "type": "date", "disclosable": false },
    { "name": "age_over_18", "type": "boolean", "disclosable": true },
    { "name": "nationality", "type": "string", "disclosable": true },
    { "name": "document_hash", "type": "hash", "disclosable": false }
  ],
  "default_policy": {
    "visible": ["age_over_18"],
    "conditional": ["nationality"],
    "hidden": ["full_name", "date_of_birth", "document_hash"]
  },
  "tags": ["identity", "compliance", "onboarding"],
  "status": "certified"
}

Parameters & Versioning

Each template supports parameterized fields that can be configured at deployment time. Versioning follows semantic versioning (major.minor.patch).

Field	Type	Description
`id`	string	Unique template identifier
`version`	semver	Template version following semantic versioning
`fields`	array	Attestation fields with type and disclosure defaults
`default_policy`	object	Default visibility configuration for each field
`status`	enum	draft \| active \| certified \| deprecated

Template Governance

Templates entering the default library undergo a governance process. Admission affects integration cost, disclosure boundaries, and buyer trust.

Module Standards

Structural and quality thresholds required for templates, policies, and verifier packages to enter the trusted set.

Access Tiers

What remains openly available vs. what requires tighter admission and oversight. Premium templates may require VLY staking.

Auditability

All template revisions, policy adjustments, and verifier prioritization decisions are traceable and reviewable.

Disclosure Policies

The policy engine transforms disclosure rules into executable system logic. Policies are independent, auditable objects — not scattered business logic.

{
  "id": "pol_abc123",
  "template_id": "kyc-basic-v2",
  "rules": [
    {
      "field": "age_over_18",
      "visibility": "always",
      "verifier_tiers": ["standard", "trusted"]
    },
    {
      "field": "nationality",
      "visibility": "conditional",
      "condition": "verifier_tier == 'trusted'",
      "expiry": "30d"
    },
    {
      "field": "full_name",
      "visibility": "never"
    }
  ],
  "created_at": "2026-04-01T00:00:00Z",
  "version": 1
}

Field Visibility Rules

Each field in a policy can have one of three visibility modes:

Mode	Behavior
`always`	Field is included in every proof output regardless of verifier tier
`conditional`	Field is included only when specified conditions are met (tier, time, context)
`never`	Field is excluded from all proof outputs — used for sensitive PII

Expiry & Trust Tiers

Policies support time-based expiry and verifier trust tiers to control proof validity windows and access levels.

Tier	Access Level	Typical Use
`standard`	Default fields only	Public verification, basic compliance
`trusted`	Default + conditional fields	Partner integrations, regulated environments
`privileged`	Full field access (except never)	Audit, legal, regulatory review

Verifier Package Structure

A verifier package contains everything the receiving party needs to verify a proof — metadata, constraints, integration guidance — in one deliverable output.

{
  "package_id": "vpkg_xyz789",
  "policy_id": "pol_abc123",
  "template": {
    "id": "kyc-basic-v2",
    "version": "2.1.0"
  },
  "proof_output": {
    "fields_included": ["age_over_18", "nationality"],
    "fields_excluded": ["full_name", "date_of_birth", "document_hash"],
    "proof_hash": "0xabc...def",
    "generated_at": "2026-04-10T12:00:00Z",
    "expires_at": "2026-05-10T12:00:00Z"
  },
  "verification": {
    "method": "zk-snark",
    "circuit_id": "veilyn-kyc-v2",
    "public_inputs": ["age_over_18", "nationality"],
    "verification_key": "vk_...",
    "instructions": "https://veilyn.xyz/docs/verify/kyc-basic"
  },
  "metadata": {
    "issuer": "veilyn-operator-001",
    "trust_tier": "trusted",
    "format_version": "1.0"
  }
}

Integration Guide

Integrating a Veilyn verifier package into your system follows a standard flow:

Receive the package

The verifier package is delivered as a JSON payload via API or file transfer. Validate the format_version field.

Verify the proof

Use the verification_key and public_inputs to verify the ZK proof against the specified circuit.

const result = await verify({
  proof: package.proof_output.proof_hash,
  publicInputs: package.verification.public_inputs,
  vk: package.verification.verification_key
});

Check constraints

Validate expiry, trust tier, and field inclusion against your requirements before accepting the attestation.

VLY Token Utility

VLY aligns access, incentives, and governance inside one operational system. Total supply: 800 billion tokens.

Premium Access

Access to certified proof templates and advanced verifier packaging capabilities requires VLY.

Staking

Template certification and verifier hosting require VLY staking as a quality assurance mechanism.

Governance

Participation in disclosure policy standards and template admission rules is coordinated through VLY.

Allocation	Share	Amount
Privacy ecosystem	30%	240B VLY
Foundation reserve	19%	152B VLY
Template growth	16%	128B VLY
Contributors	15%	120B VLY
Verifier partners	12%	96B VLY
Liquidity operations	8%	64B VLY