Starknet

Starknet scaling, smart contracts, and Ethereum settlement

Updated -

Starknet scales Ethereum through a Layer 2 network that runs smart contracts and proves their execution with STARK validity proofs. Applications share this execution environment, while Ethereum verifies the proofs and records the resulting state commitments. Cairo contracts, programmable accounts, and STRK fees shape how users interact with the network.

What can applications do on Starknet?

Applications on Starknet can exchange tokens, support lending, and run onchain games through smart contracts that share the same network state. The network supplies execution and settlement infrastructure. Each application defines the rules that govern its assets, permissions, and interactions.

Shared contracts support finance and games

Decentralized finance, often shortened to DeFi, includes trading, borrowing, and providing liquidity through contracts. Games can also keep ownership and game logic onchain, while NFT contracts represent distinct digital items. Contracts can call other contracts, so developers can combine existing components within an application. This composability depends on compatible interfaces and the behavior of each component. A validity proof checks execution against those rules; it does not establish whether a lending model or game design makes sense.

STRK20 adds optional confidentiality

STRK20 supports shielded balances and private transfers for ERC-20 assets through a privacy pool. The pool represents shielded assets as encrypted notes. Private transfers consume existing notes and create new ones, with proofs checking ownership and conservation of value. Supported wallet and application integrations determine which private actions a user can access. Ordinary public transfers remain visible, and shielding does not conceal everything: pool deposit and withdrawal amounts, and the fact of pool interaction, remain public.

The deployed privacy pool screens deposits and requires encrypted viewing-key registration. A third-party compliance operator can disclose specific transaction information in response to lawful requests. These controls limit confidentiality, even when a private transfer hides its participants and amount from public observers.

Validity proofs connect execution to Ethereum settlement

The rollup moves contract execution away from Ethereum and lets Ethereum verify proofs of the resulting changes. This shares settlement work across transaction batches.

Sequencers establish transaction order

Sequencers validate incoming transactions, order them into blocks, and execute their contract calls. Ordering determines which state each call encounters. A submission response identifies a transaction without establishing successful execution. Receipts distinguish execution outcomes from finality. Layer 2 acceptance means inclusion in a block that consensus finalizes; Ethereum acceptance means the onchain state update covers that block.

Provers check the state transition

A STARK is a scalable, transparent argument of knowledge. The proving system demonstrates that computation follows the network's execution rules. The Starknet operating system connects the starting state, transactions, and resulting state. Proof aggregation combines verification work across blocks. The Starknet Core contract requires a verified validity proof before updating the rollup state that it records on Ethereum.

Published changes support state reconstruction

A state difference describes what changed between the previous state and the next one. Publishing these differences on Ethereum lets observers reconstruct the rollup state. Ethereum blobs normally carry this data; the sequencer can use calldata when blob costs substantially exceed calldata costs. Proof verification establishes correctness; available state data allows reconstruction. Neither mechanism removes the application's own dependencies or the network's operational controls.

Cairo contracts and smart accounts shape application behavior

Cairo is the programming language that underlies the network's contracts and provable computation. Its compilation path produces Sierra and then Cairo Assembly, or CASM. The network uses its own virtual machine and contract formats, which differ from Ethereum's Solidity compilation target. Contract storage retains application data, while callable functions define how permitted interactions read or change that data.

Visual outline: Cairo contracts and smart accounts shape application behavior (Starknet)

View image file

Native account abstraction makes user accounts smart contracts with programmable authorization rules. An account can support multiple signers or another authentication scheme when its implementation provides that behavior. Wallet support and the deployed account's rules determine the actual experience. Programmable accounts also support grouping contract calls within a transaction.

A stored value within a proven batch

A storage contract changes application data, while the rollup proves the validity of the enclosing execution. In this hypothetical example, A denotes the existing stored value, and an authorized call requests replacement with B. After successful execution of the setter, the getter returns B. The account supplies authorization, while the sequencer places the call within the block's ordered execution.

The proving system checks that execution follows the required rules, and the state difference records the storage update. After Ethereum accepts the corresponding state update, the rollup commitment covers that change. The getter continues to return B unless another call changes the slot. The proof establishes correct execution; it does not validate claims about the world outside the blockchain.

Asset access depends on the network and bridge route

A compatible wallet provides access to an account, while the funding route determines how assets reach that account. Transfers from another account already on the network remain within Layer 2. Exchanges or on-ramp providers may also deliver assets directly when they support the destination network and token. Their availability and supported assets differ, so an Ethereum withdrawal option does not establish support for a Starknet withdrawal.

StarkGate's canonical Ethereum bridge transfers ETH and supported ERC-20 tokens between Ethereum and the rollup. Deposits lock assets in an Ethereum bridge contract and send a message for the corresponding Layer 2 credit. Withdrawals burn the relevant Layer 2 amount and create a message for Ethereum. Once the proof-backed state update records that message, a separate Ethereum transaction releases funds to the recorded recipient. Confirmation of the initiating transaction alone does not complete that transfer.

Bitcoin-backed assets have separate bridge assumptions. strkBTC represents BTC locked on Bitcoin and supports public and shielded modes through STRK20. Its bridge uses a federation, so Ethereum verification of rollup execution does not remove the federation's custody role. Bitcoin asset support also depends on the selected application's accepted token.

What determines the fee for a Starknet transaction?

A transaction's fee depends on its computation, data, and messaging requirements, together with the corresponding resource prices when the network processes it. These resources include Layer 2 execution and data, Ethereum data publication, and messages sent to Ethereum. Different contract calls consume different resources. Batching reduces shared settlement overhead, while larger or more demanding calls can still cost more.

Illustration: What determines the fee for a Starknet transaction?
Visual summary: What determines the fee for a Starknet transaction?

View image file

Since protocol version 0.14.0, account transactions pay fees in STRK. A transaction specifies resource bounds that limit its permitted usage and price. The fee estimate reflects a simulation against a particular state; the receipt records the actual charge. Ethereum-side bridge transactions require ETH for Ethereum gas. Deposits through StarkGate's canonical bridge also pay the message-handling fee in ETH on Ethereum. Provider charges or application fees can add further costs. When a provider sponsors a transaction, the network fee still uses STRK.

Staking and governance add economic coordination

STRK also supports staking and governance, connecting token participation to network operation and protocol decisions. Validators operate full nodes and perform the duties that the active staking phase requires. Delegators participate through validators that accept delegation, without taking over their operational duties. In the second staking phase, mainnet requires validators to stake at least 20 000 STRK. The protocol sets no minimum for delegators.

Staking also accepts a supported set of tokenized BTC representations, with rewards paid in STRK. Validator performance, commission, and the protocol's minting rules affect rewards. Second-phase mainnet unstaking includes a seven-day security lockup.

Governance participation can occur directly or through delegated voting power, under the rules of each proposal. Staking remains a staged transition toward transferring sequencing and proving responsibilities to validators. The Starknet Security Council retains administrative powers to upgrade, pause, and unpause core contracts.

Graphic: Starknet - Staking and governance add economic coordination
Staking and governance add economic coordination - diagram

View image file

Things people ask about Starknet

Do I need to learn Cairo to interact with a Starknet application?

You do not need Cairo knowledge to use an application through a supported interface and wallet. Cairo matters when writing, deploying, or examining contract code. The interface prepares calls, and the wallet handles authorization under the account's rules. Understanding the action and its permissions remains relevant even when the software handles the programming details.

Which network supports testing with faucet tokens?

Starknet Sepolia provides a test environment connected to Ethereum Sepolia. Faucet tokens fund test transactions and account deployment there. Mainnet has separate state and balances, so test funds do not provide mainnet spending power. Application availability and deployed contracts can also differ between environments; selecting a test network does not reproduce every production integration.

Why can a reverted contract call still incur a charge?

An included account transaction that reverts still consumes execution resources, so the network charges for work up to the failure. It reverses changes from the execution phase, including that phase's events and Ethereum messages. The account nonce still advances, and validation-stage changes remain. This differs from rejection before execution, which does not create the same included, reverted transaction.

Does reading a contract's stored data require a paid transaction?

A read through the starknet_call RPC method does not create a blockchain transaction or change network state. It returns the contract function's output for the selected block state without a network transaction fee. Writing a persistent change requires a transaction. A historical query can show a different value because it reads an earlier state.

Is holding STRK equivalent to owning shares in StarkWare?

STRK does not represent equity in StarkWare or the Starknet Foundation. Its roles concern network fees, staking, and governance under the applicable protocol rules. Those roles do not grant company ownership or a claim on either organization's assets. Token governance concerns network decisions, which differ from the legal rights attached to corporate shares.