The vProgs architecture rests on four foundational pillars, each addressing a distinct aspect of the system design.

The Four Pillars

Sovereign State

Each vProg owns an exclusive set of accounts and operates as a self-contained “mini zkVM.” State integrity is mutually trustless – no vProg depends on another’s correctness. Resource management (gas scales, STORM constants, storage costs) is internalized per application, preventing any single program from burdening the network.

Deep dive: Account Model & State

Off-Chain Compute

Complex execution happens entirely off-chain. The L1 never re-runs computation – it only validates cryptographic proofs. This separation enables horizontal scaling through a decentralized prover market, where total capacity grows with prover count and efficiency rather than node hardware.

Deep dive: Execution Model

L1 Sequencing

Kaspa’s BlockDAG consensus provides the global, immutable sequence of operations. The L1 acts as a “traffic controller,” ordering transactions without executing them. KIP-21 partitions sequencing commitments into per-application lanes, enabling O(activity) proving per vProg rather than O(global chain).

Deep dive: L1 Sequencing (KIP-21)

ZK Verification

Zero-knowledge proofs are the trust anchor. State transitions are attested by cryptographic proofs submitted to L1, where lightweight verification replaces heavyweight re-execution. A tiered ZK stack supports everything from mobile-friendly inline proofs to full rollup environments.

Deep dive: ZK Verification

How the Pillars Fit Together

                    +---------------------------+
                    |    Application Layer       |
                    |  (DeFi, DAOs, Enterprise)  |
                    +---------------------------+
                               |
                    +---------------------------+
                    | Synchronous Composability  |
                    | Cross-vProg atomic txns    |
                    +---------------------------+
                         /              \
          +----------------+      +------------------+
          | Sovereign State|      | Off-Chain Compute |
          | (Account Model)|      | (ZK Provers)      |
          +----------------+      +------------------+
                         \              /
                    +---------------------------+
                    |     L1 Sequencing          |
                    |  (KIP-21 Lane Commitments) |
                    +---------------------------+
                               |
                    +---------------------------+
                    |     ZK Verification        |
                    |  (KIP-16 Verifier Opcodes) |
                    +---------------------------+
                               |
                    +---------------------------+
                    |   Kaspa BlockDAG + PoW     |
                    |   DagKnight Consensus      |
                    +---------------------------+

Off-chain provers execute vProg logic and generate ZK proofs. The L1 sequences operations via the lane-based commitment structure proposed in KIP-21 and verifies proofs via the verifier opcodes specified in KIP-16. Sovereign state ensures isolation; synchronous composability enables cross-program atomicity without fragmentation.

Architecture Pages

Page Description
Architecture Overview The four pillars in depth and how they compose
Account Model & State Solana-inspired pre-declared read/write sets and sovereign state
Execution Model Off-chain execution, witness generation, proof lifecycle
ZK Verification Three-tier ZK stack, KIP-16 verifier opcodes, proof lifecycle
L1 Sequencing (KIP-21) Partitioned lanes, recursive tip hashes, sparse Merkle tree
KIP-21 to vProgs Mapping Concept mapping, what’s buildable now vs. future
Synchronous Composability Cross-vProg atomicity, concise witnesses, parallelism-aware gas
DagKnight Consensus Parameterless adaptive consensus enabling vProgs
Covenant Stack The KIP infrastructure from Crescendo to Covenants++
Silverscript Kaspa’s L1 smart contract language and its relationship to vProgs

Architectural Comparison

Feature EVM L1 L2 Rollups vProgs
Execution On-chain (heavy) Off-chain (isolated) Off-chain (unified)
Composability Synchronous Asynchronous Synchronous
Liquidity Unified Fragmented Unified
L1 Load High Minimal Minimal
Scalability Limited Bridge latency Prover market
Security Consensus Economic guarantees Cryptographic proof
Finality Block time Challenge period Instant (DagKnight)

Deployment Phases

Phase 1 – Standalone vProgs: Each vProg operates as an independent sovereign program, bridging to L1 via ZK proofs through the canonical bridge. L1 has no notion of per-account state – it is aware only of the overall vProg entity through its L1 covenant. Proving operates in O(program activity) time via KIP-21.

Phase 2 – Full Synchronous Composability: Extended Computation DAG with per-account modeling. Cross-vProg atomic transactions via concise witnesses. Full synchronous composability with the Continuous Account Dependency mechanism.

Further Reading