Use when reviewing Compact circuits for performance issues, optimizing constraint counts, analyzing proof generation time, or identifying gas and cost optimization opportunities.
Full skill instructions
Analyze circuit efficiency and identify optimization opportunities in Compact contracts.
This skill activates for queries about:
Trigger words: performance, optimization, constraints, circuit efficiency, proof generation, gas, cost
| Operation | Cost | Notes |
|---|---|---|
Addition (+) | 0 | Free in R1CS |
Subtraction (-) | 0 | Free |
Multiplication (*) | 1 | Single constraint |
Division (/) | ~1 | Includes inverse |
Equality (==) | ~1 | Direct check |
Inequality (<, >) | ~254 | Bit decomposition |
| Hash (Pedersen) | ~1,000 | Optimized |
| SHA256 | ~25,000 | Expensive |
| Merkle proof (depth N) | ~N×1,000 | Per-level hash |
Total Constraints ≈
(Hash Ops × 1,000) +
(SHA256 Ops × 25,000) +
(Comparisons × 254) +
(Merkle Depth × 1,000) +
(Loop Iterations × Body Cost)
| Optimization | Savings | Effort |
|---|---|---|
| Replace SHA256 → Pedersen | 25x per hash | Low |
Use == instead of < | ~253 constraints | Low |
| Reduce Merkle depth | ~1,000 per level | Medium |
| Move computation to witness | Variable | Medium |
Scan the contract for:
// High-cost operations
persistentHash() // ~1,000 constraints
persistentCommit() // ~1,000 constraints
sha256() // ~25,000 constraints ❌ Avoid
ecMul() // ~5,000-10,000 constraints
// Medium-cost operations
if x < y { } // ~254 constraints (bit decomposition)
for i in 0..N { } // Multiplies inner constraints by N
// Low-cost operations
x + y // Free
x * y // 1 constraint
x == y // ~1 constraint
For each loop:
1. What operations are inside?
2. How many iterations?
3. Can any operations move outside?
4. Is the loop necessary?
Example:
// ❌ Inefficient: hash inside loop
for i in 0..10 {
hashes[i] = hash(data[i]); // 10 × 1,000 = 10,000 constraints
}
// ✅ Consider: can this be done in witness?
Smaller types mean cheaper comparisons:
| Type | Comparison Cost |
|---|---|
| Uint<8> | ~8 constraints |
| Uint<64> | ~64 constraints |
| Uint<254> | ~254 constraints |
// Merkle tree with depth 20
const proof = get_merkle_proof(); // ~20,000 constraints
// Consider: Is depth 20 necessary?
// Depth 10 would be ~10,000 constraints
Use when working with Compact on-chain state management using ledger ADTs including Cell, Counter, Map, Set, List, MerkleTree, or HistoricMerkleTree, or when needing to understand which operations are available in Compact vs TypeScript.
Use when executing implementation tasks with commits after each task and reviews after each phase.
Use when starting a new Midnight project, cloning example contracts (counter, tokens, NFTs, DEX), scaffolding from OpenZeppelin templates, or bootstrapping a Compact contract development environment with working starter code.
Use when caching ZK proofs for performance, implementing proof cache invalidation, storing verification results, caching intermediate proof components, or building distributed proof caches with Redis.
Use when setting up CI/CD for Midnight projects, configuring GitHub Actions for Compact contract compilation, running TypeScript tests in CI, validating version consistency, or automating contract builds.
Use when building witness data for ZK proofs, showing proof generation progress to users, implementing disclosure consent flows, handling proof timeouts and retries, or explaining privacy guarantees.
Use when implementing any Midnight example dApp to ensure compliance with quality standards and project conventions.
Use when implementing witness functions in TypeScript, mapping Compact types to TypeScript (Field→bigint, Bytes→Uint8Array), deploying contracts, calling circuits from TypeScript, reading ledger state, or building Midnight DApps with the JavaScript SDK.
Use when reading public ledger state, implementing reactive UI that updates with chain state, caching state for performance, or understanding public vs private state in Midnight DApps.
Use when optimizing prover performance, reducing proof generation memory usage, configuring prover infrastructure in Docker or Kubernetes, implementing parallel proof generation, or diagnosing prover bottlenecks.
Use when creating a phased implementation plan from a specification, with review gates after each phase.
Use when calling deployed Midnight contracts from Node.js backends, querying contract state, executing state-changing transactions, building API endpoints that interact with contracts, or automating contract interactions.
Generate, edit, and beat-sync AI video with leading models in one workspace.
The world's fastest calendar for remote work
Transform Your Design with AI Designer by ImgCreator.ai
Revolutionizing Video Production with AI-Powered Creativity
Extend an image past the frame and let AI fill the new aspect ratio.
Discover your celebrity doppelgänger with StarByFace!
ChainClarity explains 700+ crypto whitepapers in plain English, with layered summaries, comparisons, research tools, alerts, and a $4.99 Pro plan.
Opus.ai: Revolutionize Your Web Experience