Zk Rollups

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

// Simplified zk-rollup L1 contract
contract ZKRollupL1 {
    // Verifier contract (verifies zk-SNARK proofs)
    IVerifier public verifier;
    
    // Current state root (Merkle root of all accounts)
    bytes32 public stateRoot;
    
    // Queue of forced transactions (for censorship resistance)
    bytes32[] public forcedQueue;
    
    event StateUpdated(bytes32 newRoot, uint256 batchId);
    event TransactionForced(address indexed user, bytes data);
    
    constructor(address _verifier) {
        verifier = IVerifier(_verifier);
    }
    
    // Submit batch with validity proof
    function submitBatch(
        bytes32 _newRoot,
        bytes calldata _transactionsData,
        uint256[2] memory a,
        uint256[2][2] memory b,
        uint256[2] memory c,
        uint256[] memory publicInputs
    ) external {
        // Verify the zero-knowledge proof
        require(verifier.verifyProof(a, b, c, publicInputs), "Invalid proof");
        
        // Store previous state root as public input to the proof
        // Proof should include:
        // - Previous state root
        // - New state root
        // - Batch hash of transactions
        
        stateRoot = _newRoot;
        
        emit StateUpdated(_newRoot, block.number);
    }
    
    // Forced transaction (anti-censorship)
    function forceTransaction(bytes calldata _txData) external {
        forcedQueue.push(keccak256(_txData));
        emit TransactionForced(msg.sender, _txData);
    }
    
    // Withdraw to L1 (exit from rollup)
    function withdraw(
        bytes32[] calldata _proof,
        uint256 _amount,
        address _recipient
    ) external {
        // Verify Merkle proof that user has funds
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _amount));
        require(verifyMerkleProof(_proof, stateRoot, leaf), "Invalid proof");
        
        // Transfer ETH from the rollup contract
        payable(_recipient).transfer(_amount);
    }
}

# Install zkSync Hardhat plugin
npm install -D @matterlabs/hardhat-zksync-deploy @matterlabs/hardhat-zksync-solc

// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@matterlabs/hardhat-zksync-deploy";
import "@matterlabs/hardhat-zksync-solc";

const config: HardhatUserConfig = {
  zksolc: {
    version: "1.3.17",
    compilerSource: "binary",
    settings: {
      optimizer: { enabled: true, runs: 200 },
    },
  },
  networks: {
    zkSyncSepolia: {
      url: "https://sepolia.era.zksync.dev",
      ethNetwork: "sepolia",
      zksync: true,
    },
  },
  solidity: {
    version: "0.8.19",
  },
};

export default config;

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract ZKCounter {
    uint256 public count;
    
    event CountIncremented(uint256 newCount);
    
    function increment() external {
        count++;
        emit CountIncremented(count);
    }
    
    function getCount() external view returns (uint256) {
        return count;
    }
}

// deploy.ts
import { Wallet } from "zksync-ethers";
import { Deployer } from "@matterlabs/hardhat-zksync-deploy";
import { ethers } from "hardhat";

async function main() {
  const wallet = new Wallet("YOUR_PRIVATE_KEY");
  const deployer = new Deployer(hre, wallet);
  
  const artifact = await deployer.loadArtifact("ZKCounter");
  const counter = await deployer.deploy(artifact);
  
  console.log("ZKCounter deployed to:", await counter.getAddress());
  
  // Verify
  await hre.run("verify:verify", {
    address: await counter.getAddress(),
    contract: "contracts/ZKCounter.sol:ZKCounter",
  });
}

main().catch(console.error);

// Test interaction
const { expect } = require("chai");
const { Wallet, Provider } = require("zksync-ethers");

describe("ZKCounter", function () {
  it("should increment count and emit event on zkSync", async function () {
    const provider = new Provider("https://sepolia.era.zksync.dev");
    const wallet = new Wallet("PRIVATE_KEY", provider);
    
    const counter = new ethers.Contract(
      "0x5Fb...",
      ["function increment()", "function getCount() view returns (uint256)", "event CountIncremented(uint256)"],
      wallet
    );
    
    // Increment
    const tx = await counter.increment();
    const receipt = await tx.wait();
    console.log("Gas used:", receipt.gasUsed.toString());
    
    // Verify count
    const count = await counter.getCount();
    expect(count).to.equal(1);
    
    // Gas on zkSync is ~100x cheaper than L1
    console.log("Equivalent L1 gas would be ~50,000");
    console.log("Actual zkSync gas: ~300");
  });
});

# Cairo contract example (StarkNet)
%lang starknet

from starkware.cairo.common.cairo_builtins import HashBuiltins
from starkware.starknet.common.syscalls import get_caller_address
from starkware.cairo.common.uint256 import Uint256

@storage_var
func balance(account: felt) -> (res: Uint256):
end

@external
func deposit{syscall_ptr: felt*, pedersen_ptr: HashBuiltins*, range_check_ptr}():
    let (caller) = get_caller_address()
    let (current) = balance.read(caller)
    let (amount) = Uint256(1, 0)  # Deposit 1 token
    
    let new_balance = Uint256(current.low + amount.low, current.high + amount.high)
    balance.write(caller, new_balance)
    return ()
end

@view
func get_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltins*, range_check_ptr}(
    account: felt
) -> (res: Uint256):
    let (bal) = balance.read(account)
    return (bal)
end

// L1 contract that sends a message to zkSync L2
contract L1Messenger {
    IL1Bridge public bridge;
    
    function sendMessageToL2(address _l2Contract, bytes calldata _message) external {
        // Bridge forwards the message to the zkSync mailbox
        bridge.deposit(_l2Contract, _message);
    }
}

// L2 contract receiving messages from L1
contract L2Receiver {
    address public immutable L1_MESSENGER;
    
    modifier onlyL1Messenger() {
        require(msg.sender == L1_MESSENGER, "Not L1 messenger");
        _;
    }
    
    function onMessageReceived(bytes calldata _data) external onlyL1Messenger {
        // Process the message from L1
    }
}