Introduction to Provable Smart Contracts

Provable smart contracts use cryptographic techniques to verify that computations done outside the blockchain are correct. This means that instead of doing all the work on-chain, which can be slow and expensive, the heavy lifting is done off-chain, and only a proof of the result is stored on the blockchain.

Key Benefits

1. Scalability: By handling computations off-chain, provable smart contracts reduce the load on the blockchain, allowing for more transactions to be processed at lower costs.
2. Security: Cryptographic proofs ensure that only valid computations are accepted, enhancing the security of smart contracts.
3. Privacy: Techniques like Zero-Knowledge Proofs (ZKPs) can validate transactions without revealing any sensitive information.

StarkNet and Cairo

StarkNet is a Layer-2 network on Ethereum that uses STARK (Scalable Transparent Argument of Knowledge) proofs to provide scalability and security. It allows developers to build dApps that can handle many transactions per second while benefiting from Ethereum’s security.

StarkNet Architecture

State Changes and STARK Proofs in StarkNet

When a smart contract is executed on StarkNet, it involves state changes. These state changes are the updates made to the contract’s storage as a result of executing its functions. To ensure the correctness of these state changes, StarkNet generates and verifies STARK proofs.

Here’s a step-by-step explanation of how this process works:

1. Smart Contract Execution

When a user interacts with a smart contract on StarkNet, for instance, by calling a function like increase_counter, the following steps occur:

• Function Call: The function is invoked with specific inputs. For example, calling increase_counter(10) to increase the counter by 10.
• Computation: The StarkNet virtual machine (VM) executes the function, performing the necessary computations to update the contract’s state. This involves reading the current state, applying the changes, and writing the new state back to storage.

2. Trace Generation

During the execution of the smart contract, StarkNet generates a trace. The trace is a detailed log of every computational step taken during the execution, including the initial state, the operations performed, and the resulting state. This trace is crucial for generating the proof.

3. STARK Proof Generation

Using the trace generated in the previous step, StarkNet produces a STARK proof. This proof is a cryptographic certificate that attests to the correctness of the computation and the resulting state changes. Here’s how it works:

• Data Representation: The trace is converted into a format suitable for cryptographic operations.
• Proof Computation: Using the STARK protocol, the proof is computed. This involves complex mathematical operations that produce a concise representation of the trace’s correctness.

4. Proof Submission and Verification

The generated STARK proof, along with the new state changes, is submitted to the Ethereum mainnet for verification. This is where the efficiency of STARKs shines:

• On-Chain Verification: Instead of re-executing the entire computation, the Ethereum smart contract (StarkNet Verifier) only needs to verify the STARK proof. This verification process is much faster and requires significantly less computational power than re-execution.
• State Commitment: Once the proof is verified, the new state changes are accepted and committed to the StarkNet state.

Example Workflow

Let’s consider our counter contract to illustrate this process:

1. Initial State: Assume the counter value is 0.
2. Function Call: A user calls increase_counter(10).
3. Computation: The StarkNet VM computes the new counter value, which is 10.
4. Trace Generation: A trace is generated that logs the initial counter value (0), the increment operation, and the resulting counter value (10).
5. Proof Generation: Using the trace, a STARK proof is generated that certifies the computation (0 + 10 = 10) was performed correctly.
6. Proof Submission: The STARK proof, along with the new counter value (10), is submitted to the Ethereum mainnet.
7. Verification: The Ethereum smart contract verifies the STARK proof.
8. State Commitment: Upon successful verification, the new counter value (10) is committed to StarkNet’s state.

What is the Cairo Language?

Cairo (Computer Algebra for RISC Operations) is a programming language specifically designed for writing provable programs. It is the native language for developing smart contracts on StarkNet, leveraging zero-knowledge proofs to ensure computational integrity.

Key Features of Cairo:

1. Proof Generation: Cairo allows for the creation of succinct proofs that attest to the correctness of a computation.
2. Efficiency: Designed for high-performance computations, Cairo can handle complex algorithms efficiently.
3. Interoperability: Cairo smart contracts can interact seamlessly with Ethereum and other blockchain platforms.

In this article, we will explore the steps to build, deploy, and interact with a smart contract on StarkNet.

Prerequisites

Before we start, make sure you have the following installed:

1. Rust (>= 1.51.0)
2. cargo (Rust's package manager)
3. Node.js (>= 12.x)
4. npm (Node Package Manager)
5. starknet-devnet (StarkNet local testnet)
6. starknet CLI
7. scarb (Cairo’s package manager for Rust)

You can install the necessary tools using the following commands:

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Install Node.js and npm (if not already installed)
sudo apt-get install nodejs
sudo apt-get install npm

# Install StarkNet CLI
pip install starknet-devnet

# Install Scarb (Cairo's package manager for Rust)
curl -L https://github.com/software-mansion/scarb/releases/download/latest/scarb-x86_64-unknown-linux-gnu.tar.gz | tar xz
sudo mv scarb /usr/local/bin

Setting Up StarkNet Devnet

Start StarkNet Devnet with the following command:

starknet-devnet

This command will start a local instance of StarkNet Devnet on http://localhost:5000.

Creating the Rust Cairo Project

Create a new Rust project and add the necessary dependencies for Cairo. Run the following commands:

cargo new starknet_counter
cd starknet_counter

Add the following dependencies to your Cargo.toml file:

[dependencies]
cairo = "0.1"
starknet = { git = "https://github.com/starkware-libs/cairo.git" }

Writing the Smart Contract

Create a file named src/main.rs and add the following code for a simple counter contract:

use cairo::contract;
use cairo::types::felt::Felt252;
use cairo::starknet::storage::Storage;
use cairo::starknet::types::Address;

#[contract]
mod counter {
    use super::*;
    #[storage]
    struct Storage {
        counter: Felt252,
    }

    #[constructor]
    fn new() -> Storage {
        Storage {
            counter: Felt252::from(0),
        }
    }

    #[external]
    fn increase_counter(storage: &mut Storage, amount: Felt252) {
        storage.counter += amount;
    }

    #[view]
    fn get_counter(storage: &Storage) -> Felt252 {
        storage.counter
    }
}

This contract defines a simple counter with two functions:

1. increase_counter(amount: Felt252): Increases the counter by a specified amount.
2. get_counter() -> Felt252: Retrieves the current value of the counter.

Compiling the Contract

Compile the contract using the Scarb tool:

scarb build

This will generate the necessary compiled files in the target directory.

Deploying the Contract

Deploy the compiled contract to StarkNet Devnet using the StarkNet CLI:

starknet deploy --contract target/release/starknet_counter.sierra.json --abi target/release/starknet_counter.abi.json --network localhost

Take note of the contract address and transaction hash from the deployment output. You’ll need the contract address to interact with the contract.

Interacting with the Contract

To interact with the contract, we will use the StarkNet CLI. First, let’s increase the counter by 10.

starknet invoke --function increase_counter --inputs 10 --address <contract_address> --abi target/release/starknet_counter.abi.json --network localhost

Replace <contract_address> with the actual contract address obtained from the deployment step.

Next, let’s query the current value of the counter.

starknet call --function get_counter --address <contract_address> --abi target/release/starknet_counter.abi.json --network localhost

This should return 10 as we have just increased the counter by 10.

L1-L2 Messaging

L1-L2 messaging refers to the communication protocol between a Layer-1 blockchain and its Layer-2 solutions. Layer-2 solutions are designed to handle transactions off the main blockchain to improve scalability, reduce transaction fees, and increase throughput. These solutions must still interact with the L1 blockchain to ensure security, interoperability, and finality of transactions.

How Does L1-L2 Messaging Work?

L1-L2 messaging typically involves a few key steps:

1. Transaction Initiation on L2:

• A user initiates a transaction on an L2 solution, such as a payment or a smart contract execution.
• The transaction is processed off-chain, taking advantage of the L2’s scalability and lower costs.

2. Generating Proofs:

• After processing the transaction, the L2 solution generates a cryptographic proof of the transaction’s validity.
• This proof is a succinct representation of the transaction data, ensuring that it can be efficiently verified on the L1 blockchain.

3. Submitting Proofs to L1:

• The generated proof is submitted to the L1 blockchain.
• This submission can happen periodically, with multiple transactions batched together to further reduce costs.

4. Verification and Finalization on L1:

• The L1 blockchain verifies the cryptographic proofs.
• Once verified, the transactions processed on the L2 are considered final and secure, leveraging the L1 blockchain’s security.

Example: StarkNet and Cairo

Creating the Rust Cairo Project

Create a new Rust project and add the necessary dependencies for Cairo. Run the following commands:

cargo new l1_l2_messaging
cd l1_l2_messaging

Add the following dependencies to your Cargo.toml file:

[dependencies]
cairo-lang = "0.6.2"
starknet = { git = "https://github.com/starkware-libs/starknet-rs.git" }

Writing the Cairo Contract in Rust

Create a file named src/main.rs and add the following code for an L1-L2 messaging contract:

use cairo::contract;
use cairo::types::felt::Felt252;
use cairo::starknet::storage::Storage;
use cairo::starknet::types::Address;

#[contract]
mod l1_l2_messaging {
    use super::*;

    #[storage]
    struct Storage {
        message: Felt252,
    }

    #[constructor]
    fn new() -> Storage {
        Storage {
            message: Felt252::from(0),
        }
    }

    #[external]
    fn send_message(storage: &mut Storage, sender: Felt252, message: Felt252) {
        storage.message = message;
        emit_message_sent(sender, message);
    }

    #[view]
    fn get_message(storage: &Storage) -> Felt252 {
        storage.message
    }

    #[event]
    fn emit_message_sent(sender: Felt252, message: Felt252);
}

Compiling the Contract

Compile the contract using the Scarb tool:

scarb build

Deploying the Contract

Deploy the compiled contract to StarkNet Devnet using the StarkNet CLI:

starknet deploy --contract target/release/l1_l2_messaging.sierra.json --abi target/release/l1_l2_messaging.abi.json --network localhost

Take note of the contract address from the deployment output.

Interacting with the Contract

1. Send a Message:

starknet invoke --function send_message --inputs 123 456 --address <contract_address> --abi target/release/l1_l2_messaging.abi.json --network localhost

Replace <contract_address> with the actual contract address obtained from the deployment step. Here, 123 is the sender's address, and 456 is the message.

2. Get the Stored Message:

starknet call --function get_message --address <contract_address> --abi target/release/l1_l2_messaging.abi.json --network localhost

Explanation

• send_message(sender: Felt252, message: Felt252): This function allows a sender to send a message, which is then stored in the contract’s storage. It also emits an event emit_message_sent with the sender and the message.
• get_message(): This view function retrieves the stored message from the contract’s storage.
• emit_message_sent(sender: Felt252, message: Felt252): This event function emits a message event for tracking purposes.

Useful Resources for StarkNet and Cairo

To further explore StarkNet and Cairo, the following resources will provide you with comprehensive guides, documentation, and community support:

Official Documentation

• StarkNet Documentation: StarkNet Docs
• Cairo Language Documentation: Cairo Lang Docs

Development Tools

• StarkNet CLI: StarkNet CLI GitHub
• Scarb (Cairo’s Package Manager for Rust): Scarb GitHub

Learning Resources

• StarkNet Base: StarkNet Base
• Cairo Tutorial: Cairo Tutorial

Community and Support

• StarkNet Community: StarkNet Community
• StarkNet Discord: StarkNet Discord
• Cairo GitHub: Cairo GitHub

Example Projects

• StarkNet Examples: StarkNet Examples GitHub
• Cairo Example Projects: Cairo Examples GitHub

These resources will help you get started with developing on StarkNet and writing smart contracts using Cairo, providing you with the necessary tools, tutorials, and community support to build scalable and secure dApps.