What is Steel?

The ZK Coprocessor for EVM apps.

Steel: The ZK Coprocessor for EVM apps

“Unbounded EVM computation made simple”

Steel lets Solidity developers effortlessly scale their applications by moving computation offchain without compromising on onchain security. Steel drastically reduces gas costs and this enables previously impossible applications.

Steel pulls state from any EVM chain, performs verifiable computation across multiple blocks offchain, and generates concise execution proofs. Developers simply verify these proofs onchain to access boundless compute, without worrying about gas limits.

A single Steel proof has verified a computation equivalent to 30 Ethereum blocks—saving 1.2 billion gas—generated for under $10 and verified onchain for under 300k gas.

Onchain vs offchain execution

Onchain execution is limited by the gas limit per block. This is fine for simple execution, but most real-world applications require significantly more capability than what is currently available, even on layer 2 rollups. With Steel, developers can carry out the same EVM execution they would onchain, but at a much larger scale. This EVM execution is within a boundless and verifiable environment offchain within the zkVM, allowing for an unprecedented amount of scaling for EVM applications.

To describe how Steel replaces onchain execution with onchain verification of smart contract execution proofs, we will walk through a simple example: a counter variable is incremented if, and only if, the ERC20 balance of a certain account is larger than 1.

This example is purely instructive and by simplifying the execution, we can focus on understanding the specifics of Steel.

Without Steel

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract OnChainERC20Counter {
    address public tokenContract;
    uint256 public counter;

    function checkBalance(address accountAddress) public view returns (uint256) {
        return IERC20(tokenContract).balanceOf(accountAddress);
    }

    // this function will only update the counter if the account has a valid balance > 1
    function increment(address accountAddress) public {
        require(checkBalance(accountAddress) > 1, "balance must be greater than 1");
        counter += 1;
    }
}

The increment function uses the checkBalance function to return ERC20 the current balance of the account, and the require statement makes sure that the counter is only updated if the balance is larger than 1.

With Steel

contract OffChainERC20Counter() {
    address public tokenContract;
    uint256 public counter;

    // this function will only update the counter if the account has a valid balance > 1
    function increment(bytes calldata journalData, bytes calldata seal) public {
        // Decode and validate the journal data
        Journal memory journal = abi.decode(journalData, (Journal));
        require(journal.tokenContract == tokenContract, "Invalid Token Address");
        require(Steel.validateCommitment(journal.commitment), "Invalid Steel Commitment");

        // Verify the execution proof
        bytes32 journalHash = sha256(journalData);
        verifier.verify(seal, imageID, journalHash);

        counter += 1;
    }
}

To make sure that Steel’s execution proofs can be trusted, we check the output of the zkVM program to make sure that the token contract address is correct, and we validate the Steel Commitment. Only if these are valid, the proof is verified. Upon successful verification, we can be sure that the account balance is larger than 1 and we increment the counter variable. Notice there is no check onchain of the balance or any EVM execution other than the validations and proof verification. The EVM execution happens within the zkVM guest program.

In How does Steel work?, we dive deeper into how exactly the zkVM guest program verifies state access and runs EVM execution, generating a smart contract execution proof, and verifying the proof onchain.