dex-vprog/
  src/
    lib.rs                  # Pool state schema and transition logic
    pool.rs                 # Constant-product AMM math (x * y = k)
    lp_token.rs             # Liquidity provider token accounting
    fees.rs                 # Fee calculation and distribution
  covenants/
    liquidity_pool.ss       # Silverscript: deposit/withdraw LP rules
    swap_order.ss           # Silverscript: swap execution covenant
  tests/
    pool_tests.rs           # AMM invariant tests
    integration.rs          # Full swap lifecycle test

multisig-wallet/
  covenants/
    multisig.ss             # Main multi-sig covenant
    recovery.ss             # Time-locked recovery path
  scripts/
    deploy.sh               # Deployment script
  tests/
    signing_tests.rs        # Threshold signature tests

pragma silverscript ^0.1.0;

contract MultiSig(
    pubkey[5] signers,      // Up to 5 signers
    int threshold            // M-of-N threshold
) {
    entrypoint function spend(sig[] signatures, int[] signerIndices) {
        // Verify at least M valid signatures
        require(signatures.length >= threshold);

        for (i, 0, signatures.length, 5) {
            int idx = signerIndices[i];
            require(idx >= 0);
            require(idx < 5);
            require(checkSig(signatures[i], signers[idx]));
        }
    }

    // Emergency recovery after 90 days with any single signer
    entrypoint function emergencyRecover(sig singleSig, int signerIdx) {
        require(this.age >= 90 days);
        require(signerIdx >= 0);
        require(signerIdx < 5);
        require(checkSig(singleSig, signers[signerIdx]));
    }
}

dutch-auction/
  covenants/
    auction.ss              # Main auction covenant
    settlement.ss           # Post-auction settlement
  tests/
    price_decay_tests.rs    # Verify price schedule

pragma silverscript ^0.1.0;

contract DutchAuction(
    pubkey seller,
    int startPrice,         // Starting price in sompis
    int reservePrice,       // Minimum price (floor)
    int duration,           // Auction duration in seconds
    int decayRate           // Price drop per second
) {
    // Buy at the current price
    entrypoint function buy(sig buyerSig, pubkey buyer) {
        // Calculate current price based on elapsed time
        int elapsed = this.age;
        int priceDrop = elapsed * decayRate;
        int currentPrice = startPrice - priceDrop;

        // Enforce reserve price floor
        if (currentPrice < reservePrice) {
            currentPrice = reservePrice;
        }

        // Buyer must pay at least the current price
        // First output goes to seller
        require(tx.outputs[0].value >= currentPrice);
    }

    // Seller can cancel the auction at any time
    entrypoint function cancel(sig sellerSig) {
        require(checkSig(sellerSig, seller));
    }
}

escrow-service/
  covenants/
    escrow.ss               # Main escrow covenant
  tests/
    escrow_tests.rs         # Lifecycle tests (deposit, release, dispute, timeout)

pragma silverscript ^0.1.0;

contract Escrow(
    pubkey buyer,
    pubkey seller,
    pubkey arbiter,
    int timeout             // Auto-refund timeout in seconds
) {
    // Seller delivers, buyer confirms release
    entrypoint function release(sig buyerSig) {
        require(checkSig(buyerSig, buyer));
        // Funds go to seller (enforced by output check)
    }

    // Buyer requests refund, seller agrees
    entrypoint function refund(sig sellerSig) {
        require(checkSig(sellerSig, seller));
        // Funds return to buyer
    }

    // Arbiter resolves a dispute
    entrypoint function arbitrate(sig arbiterSig, bool releaseToSeller) {
        require(checkSig(arbiterSig, arbiter));
        // Arbiter decides: funds go to seller or buyer
    }

    // Auto-refund after timeout
    entrypoint function timeoutRefund(sig buyerSig) {
        require(checkSig(buyerSig, buyer));
        require(this.age >= timeout);
        // Funds return to buyer after timeout
    }
}

dao-governance/
  src/
    lib.rs                  # Governance state schema
    proposal.rs             # Proposal lifecycle (create, vote, execute)
    voting.rs               # Vote tallying and quorum logic
    treasury.rs             # Treasury allocation rules
  covenants/
    treasury.ss             # Silverscript: treasury spending covenant
    membership.ss           # Silverscript: membership token rules
  tests/
    governance_tests.rs     # Proposal lifecycle tests
    quorum_tests.rs         # Quorum and threshold tests

pragma silverscript ^0.1.0;

contract Treasury(bytes verificationKey, int quorum) {
    // Execute a passed proposal by spending treasury funds
    // Requires a ZK proof that the vote tally is correct
    entrypoint function execute(
        bytes proof,
        bytes32 proposalHash,
        int amount
    ) {
        // Verify the ZK proof that the proposal passed
        bytes publicInputs = encodePublicInputs(proposalHash, amount);
        require(zkVerify(verificationKey, proof, publicInputs));

        // Output the specified amount to the proposal recipient
        require(tx.outputs[0].value == amount);
    }
}

chess-covenant/
  covenants/
    league.ss               # Registration and matchmaking
    player.ss               # Identity, funds, score tracking
    mux.ss                  # Board state owner, move router
    worker_pawn.ss          # Pawn move validation
    worker_castle.ss        # Castling validation
    worker_enpassant.ss     # En passant validation
    settle.ss               # Game settlement and scoring
  tests/
    move_tests.rs           # Individual move validation
    game_lifecycle.rs       # Full game: register → play → settle
    icc_tests.rs            # Cross-covenant authorization tests

1. Player signs a transaction including their Player UTXO + Mux UTXO
2. Mux authenticates (ICC: Player covenant co-authorizes)
3. Mux reads the move selector → routes to correct Worker
4. Worker validates the specific move against chess rules
5. Transaction outputs: updated Mux (new board state) + recreated Player

pragma silverscript ^0.1.0;

contract ChessMux(
    bytes32 player_template,     // Template selector: Player role
    bytes32 worker_templates[6], // Template selectors: one per piece type
    bytes32 board_state          // Current board hash
) {



---

## 7. ZK Rollup Covenant (KIP-21)

A complete end-to-end example of a ZK rollup covenant built on the KIP-21 partitioned sequencing commitment. It demonstrates the full lifecycle from L1 transactions to rollup execution and L1 exits, serving as a powerful starting point for building with vProgs.

**Architecture:**

- **vProg:** Executes L2 transfers and state updates off-chain.
- **Covenants:** Manages the canonical bridge, verifying ZK proofs for deposits and withdrawals.
- **ZK Backend:** RISC Zero (STARK) and Groth16.
- **Performance Target:** Demonstrates up to 1,000 transactions per second (TPS) on L2.

**Key features:**

- Full deposit-transfer-withdraw cycle
- Sparse Merkle Tree for L2 account state
- Blake3 hashing for high-performance sequencing commitments
- Forward compatibility: efficiently filters legacy transactions by checking the transaction version in the KIP-21 commitment

    #[covenant.singleton(mode = transition)]
    entrypoint function makeMove(
        int pieceType,           // Selector: which worker to route to
        int fromSquare,
        int toSquare,
        sig playerSig
    ) : (bytes32 new_board_state) {
        // ICC: verify Player covenant is co-input in this transaction
        // (Player covenant independently verifies the user's signature)
        require(hasCovenantInput(player_template));

        // Route to the correct worker via template selector
        require(hasCovenantInput(worker_templates[pieceType]));

        // Worker validates the move; if we reach here, it passed
        // Compute new board state
        return applyMove(board_state, fromSquare, toSquare);
    }
}