Agent skill
midnight-proofs:proof-verification
Use when verifying ZK proofs server-side, validating proofs before transaction submission, building verification gateways, implementing batch verification, or debugging proof generation issues.
Install this agent skill to your Project
npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/other/other/proof-verification
SKILL.md
Proof Verification
Verify ZK proofs server-side before transaction submission to catch invalid proofs early and reduce failed transactions.
When to Use
- Validating proofs before submitting transactions to the network
- Building a verification gateway for incoming proofs
- Implementing batch verification for high-throughput systems
- Checking proof validity as part of an API request
- Debugging proof generation issues
Key Concepts
Why Verify Server-Side?
| Benefit | Description |
|---|---|
| Fail fast | Catch invalid proofs before network submission |
| Save gas | Avoid transaction fees for invalid proofs |
| Better UX | Provide immediate feedback to users |
| Security | Validate proofs from untrusted clients |
Verification vs Validation
- Verification - Cryptographic check that proof is valid for the circuit
- Validation - Business logic checks (e.g., correct public inputs)
// Both verification and validation
async function verifyAndValidate(proof: Proof, publicInputs: PublicInputs): Promise<boolean> {
// Step 1: Cryptographic verification
const isValidProof = await verifier.verify(proof, publicInputs);
if (!isValidProof) return false;
// Step 2: Business validation
const isValidBusiness = validateBusinessRules(publicInputs);
return isValidBusiness;
}
Verification Performance
Verification is much faster than proof generation:
| Operation | Typical Duration |
|---|---|
| Proof Generation | 5-30 seconds |
| Proof Verification | 10-100 milliseconds |
References
| Document | Description |
|---|---|
| verification-api.md | Verifier SDK setup and API reference |
Examples
| Example | Description |
|---|---|
| pre-submit-validation/ | Verify before transaction submit |
| batch-verification/ | Verify multiple proofs in parallel |
Quick Start
1. Set Up Verifier
import { createVerifier } from '@midnight-ntwrk/midnight-js-verifier';
const verifier = await createVerifier({
verificationKeysPath: './circuit-keys',
});
2. Verify a Single Proof
async function verifyProof(
circuitId: string,
proof: Uint8Array,
publicInputs: Record<string, unknown>
): Promise<boolean> {
try {
const result = await verifier.verify(circuitId, proof, publicInputs);
return result.valid;
} catch (error) {
console.error('Verification failed:', error);
return false;
}
}
3. Verify Before Submit
async function submitWithVerification(
transaction: Transaction
): Promise<string> {
// Extract proof and public inputs from transaction
const { proof, publicInputs, circuitId } = transaction;
// Verify first
const isValid = await verifyProof(circuitId, proof, publicInputs);
if (!isValid) {
throw new Error('Proof verification failed');
}
// Submit to network
return await submitTransaction(transaction);
}
Common Patterns
Verification Gateway
import express from 'express';
const app = express();
app.post('/api/verify', async (req, res) => {
const { circuitId, proof, publicInputs } = req.body;
try {
const result = await verifier.verify(
circuitId,
Buffer.from(proof, 'base64'),
publicInputs
);
res.json({
valid: result.valid,
circuitId,
verificationTime: result.duration,
});
} catch (error) {
res.status(400).json({
valid: false,
error: error.message,
});
}
});
Batch Verification
interface ProofBatch {
circuitId: string;
proof: Uint8Array;
publicInputs: Record<string, unknown>;
}
async function verifyBatch(
proofs: ProofBatch[]
): Promise<Map<number, boolean>> {
const results = new Map<number, boolean>();
// Verify in parallel
const verifications = proofs.map(async (p, index) => {
try {
const result = await verifier.verify(
p.circuitId,
p.proof,
p.publicInputs
);
results.set(index, result.valid);
} catch {
results.set(index, false);
}
});
await Promise.all(verifications);
return results;
}
Caching Verified Proofs
import { createHash } from 'crypto';
const verifiedProofs = new Map<string, boolean>();
function proofHash(proof: Uint8Array, publicInputs: Record<string, unknown>): string {
const data = JSON.stringify({ proof: proof.toString(), publicInputs });
return createHash('sha256').update(data).digest('hex');
}
async function verifyWithCache(
circuitId: string,
proof: Uint8Array,
publicInputs: Record<string, unknown>
): Promise<boolean> {
const hash = proofHash(proof, publicInputs);
// Check cache
if (verifiedProofs.has(hash)) {
return verifiedProofs.get(hash)!;
}
// Verify
const result = await verifier.verify(circuitId, proof, publicInputs);
verifiedProofs.set(hash, result.valid);
return result.valid;
}
Verification with Timeout
async function verifyWithTimeout(
circuitId: string,
proof: Uint8Array,
publicInputs: Record<string, unknown>,
timeoutMs = 5000
): Promise<boolean> {
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), timeoutMs);
try {
const result = await verifier.verify(circuitId, proof, publicInputs, {
signal: controller.signal,
});
return result.valid;
} catch (error) {
if (error.name === 'AbortError') {
throw new Error('Verification timeout');
}
throw error;
} finally {
clearTimeout(timeout);
}
}
Error Classification
enum VerificationError {
INVALID_PROOF = 'INVALID_PROOF',
INVALID_PUBLIC_INPUTS = 'INVALID_PUBLIC_INPUTS',
CIRCUIT_NOT_FOUND = 'CIRCUIT_NOT_FOUND',
MALFORMED_PROOF = 'MALFORMED_PROOF',
TIMEOUT = 'TIMEOUT',
}
function classifyVerificationError(error: Error): VerificationError {
if (error.message.includes('circuit')) {
return VerificationError.CIRCUIT_NOT_FOUND;
}
if (error.message.includes('public input')) {
return VerificationError.INVALID_PUBLIC_INPUTS;
}
if (error.message.includes('malformed')) {
return VerificationError.MALFORMED_PROOF;
}
if (error.message.includes('timeout')) {
return VerificationError.TIMEOUT;
}
return VerificationError.INVALID_PROOF;
}
Performance Considerations
| Concern | Mitigation |
|---|---|
| Verification key loading | Preload keys at startup |
| High request volume | Use verification caching |
| Large batches | Limit concurrent verifications |
| Memory usage | Stream large proof batches |
Related Skills
proof-generation- Generate proofs server-sideproof-caching- Cache verification resultsprover-optimization- Optimize prover that creates proofs
Related Commands
None currently defined.
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
majiayu000/claude-skill-registry
agent-ops-spec
Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.
majiayu000/claude-skill-registry
agent-ops-state
Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.
majiayu000/claude-skill-registry
agent-ops-spec
Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.
majiayu000/claude-skill-registry
agent-ops-testing
Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.
majiayu000/claude-skill-registry
agent-ops-testing
Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.
majiayu000/claude-skill-registry
agent-ops-state
Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.
Didn't find tool you were looking for?