Starknet release notes

Optimistic parallelization in the sequencer.

Applicative recursion ("blockpacking"): pack a contiguous sequence of blocks into a single L1 state update, instead of just one block. This change also affects the Starknet core contract on L1 and the structure of data availability:

New block hash definition: see the reference implementation here.

Cheaper data availability (DA): Starknet uses EIP-4844. State diffs are now blobs, rather than calldata, requiring the addition of data_gas to the Starknet block header.

Time-related syscalls when called from an account contract’s __validate__, __validate_deploy__, __validate_declare__, or constructor function:

Optimization: Load into memory only the functions in a contract that are actually used when generating the proof.

l1_da_mode: A string enum that takes the value CALLDATA or BLOB, and indicates whether EIP-4844 is the data availability solution that is used for the block. Also appears in pending block.

l1_data_gas_price: Contains price_in_wei and price_in_fri, where 1 fri is 10^-18 STRK. Also appears in pending block.

l1_gas_price: Replaces eth_l1_gas_price and strk_l1_gas_price. Contains the data gas price (EIP-4844) in addition to the regular gas price.

l1_data_gas_price: contains price_in_wei and price_in_fri (10^-18 denominations, similar to v0.6.0).

l1_da_mode: An enum that indicates whether this block will use calldata or blobdata and can take the following values:

Includes two new fields:

overall_fee is now:
gas_consumed × gas_price + data_gas_consumed × data_gas_price

Fee estimates will change depending on the data availability solution used by current Starknet blocks. For example, if you estimate the fee against the pending block, and it’s currently using CALLDATA, then nodes are expected to return data_gas_consumed=0 and compute the fee similarly to today, that is, get higher estimates.

COMMON_RECEIPT_PROPERTIES, the main receipt object, now includes a new entry: execution_resources.

The EXECUTION_RESOURCES object now includes the field data_availability. Note that the resources of internal calls will remain the same/

For more information, see the PR for the API JSON RPC specs

Computation resources are separated from data availability resources. This is done by introducing the data_availability property, which includes l1_gas and l1_data_gas, which were consumed due to DA requirements. One of these will always be zero, depending on whether or not the block uses calldata or blobs, as specified by the l1_da_mode field in the block header.

Syscall costs are now included in the execution resources of traces and receipts. These are costs that are already being paid for but were not reported so far.

A Cairo step now costs 0.0025 gas/step, a 50% reduction.

All builtins costs are accordingly reduced by 50%.

Each felt of a sierra_program in the contract class and of bytecode in the compiled contract class now costs 28 gas/felt.

Each character in the ABI costs 0.875 gas.

An additional felt to the data array of an event now costs 0.128 gas/felt, similar to calldata.

An additional felt to the keys array now costs 0.256 gas/felt.

Starknet v0.13.1: EIP4844 Support, More Fee Reductions, Stability, Quality of Life

Starknet v0.13.1: Fee Reduction

Data availability with EIP4844

Starknet v0.13.1 pre-release notes

v3 transactions, including:

get_block API: The gas_price field is replaced by the eth_l1_gas_price and strk_l1_gas_price fields. This change applies also to existing blocks. For more information on the new fields, see the JSON RPC API Spec on GitHub

Sierra v1.4.0. This new version of Sierra is part of Crate v2.4.0, in the Cairo 2.4.0 package. For more information, see Cairo v2.4.0 is out! on the Community forum.

Improved performance of secp256k1_mul and secp256r1_mul syscalls

Computation cost is reduced by approximately 50% as a result of reduced Cairo steps and increased use of builtins. L1 data availability cost is reduced by approximately 10%-25%. For an ERC-20 transfer, the DA fee reduction is 25%.

Performance optimizations in the gateway, the computation of the Patricia storage root, and block hash

Support for secp256r1 syscalls in the Starknet OS.

Restriction for __validate__ and the constructor of DeployAccount transactions:

Enabling P2P Authentication: An additional endpoint in the sequencer gateway to provide a signature on the state diff commitment and block hash.

Resolving Mismatches in Queries: An extension to the get_state_update endpoint in the sequencer gateway that returns both the pending state diff and the pending block together.

Increased maximum Cairo steps per transaction from 1 million to 3 million.

Mempool Validation.

Inclusion of Failed Transactions.

Keccak builtin.

Use the rust blockifier and LambdaClass’s Cairo VM to accelerate the sequencer’s time to handle transactions.

Support version 2.0.0 of the Cairo compiler.

Replace the PENDING status of transactions to ACCEPTED_ON_L2 - once a transaction is in that status it means that it will be included in a block, this applies to transactions - blocks still have the PENDING status.

Add an experimental get_block_hash syscall.

Change HTTP error code from 500 to 400 on API errors.

Upgrade Cairo 1.0 version to v1.0.0-rc0 (Cairo 1.0 activated on Starknet!)

Upgrade Cairo 1.0 version to v1.0.0-rc0.

Charged transaction fee is now based on an average Ethereum gas price instead of a single sample (estimation API is unaffected).

API changes:

Testing framework:

Add current block hash to the Starknet Core Contract (currently not verified by the Starknet OS):

A new version of the declare transaction, which allows sending the new class structure

The state commitment will now include contract classes

Changes to the onchain data format

New system call - replace_class

Performance - Separate the state commitment computation from the execution of the transactions

Add starknet-class-hash command to compute the class hash of a compiled Starknet contract

Autoformatter: Automatically break lines inside expressions

This version introduces sequencer parallelization! This is the first step in our roadmap of performance upgrades. Details about the specific mechanism of parallelization and the roadmap in general are described in this medium post.

A new endpoint, estimate_fee_bulk, is added to the feeder gateway. This will allow estimating the fee of several transactions at once, where each transaction is executed relative to the resulting state from applying the previous one.

Add DeployAccount transaction (which will replace the Deploy transaction for deploying account contracts). To use it, you should first add enough funds to your account address to pay the transaction fee, and then you can invoke DeployAccount

Split the starknet deploy_account CLI command into starknet new_account and starknet deploy_account

Account contracts that are expected to be deployed this way should implement the`validate_deploy()` entry point, which should check the signature of the DeployAccount transaction

Improve L1 fee computation: the fee is computed according to the diff of the storage state

API: Remove entry_point_type field from transaction information

Add uint256_mul_div_mod to uint256.cairo

Contract (breaking changes):

New transaction version (version 1) for invoke and declare transactions:

Add nonce field to the transactions. Nonce validation is now part of the Starknet protocol and is enforced to be executed sequentially

Invoke:

Declare:

You can use the cairo-migrate script to convert old code to the new syntax. Use the -i flag to apply the changes to the files

End statements with ;

Use { … } for code blocks (instead of : and end)

Add () around the condition of if statements

Remove the member keyword in structs

Change comment to use // instead of #

Use …​, ap` instead of `...; ap in low level Cairo code

Support return types that are not tuples. For example, func foo() → felt (instead of func foo() → (r: felt)) As a result, it’s now mandatory to specify return types. func foo() → (res) should be replaced by func foo() → (res: felt). The cairo-migrate tool does that automatically.

Return statement accepts expressions, rather than only tuples. For example, you can write let x = (5,); return x;

A few standard library functions were changed to return felt. The cairo-migrate script also fixes calls to those functions

Support using functions as expressions

This only applies to functions with → felt signature`, whose ap change is known at compile-time (e.g., recursive functions cannot be used this way)

Fix a bug in the secp signature verification code that allowed a malicious prover to ignore the value of v (this does not let the prover fake a signature, but allows it to claim that a valid signature is invalid).

Add Cairo code for the recursive STARK verifier

Add get_block_traces API - returns all the transaction traces of a given block

Add a list of declared contracts in get_state_update

Add a 0x prefix for class hash in the API

Add starknet_version field for blocks (only applies to new blocks)

Change the default block number to pending

Using a wallet is the default, --no_wallet must be specified explicitly to override this

Deploying contracts:

Support --dry_run to get the transaction information without signing or sending it

Support deploy_from_zero in the deploy syscall to deploy a contract to an address that does not depend on the deployer

Enforce fees - max_fee must not be set to zero, and selector must be execute

Split the concepts of contract class and contract instance.

Add declare transaction type

New API and CLI commands:

declare - Declares a contract class

get_class_by_hash - Returns the contract class given its hash

get_class_hash_at - Returns the class hash for a given contract instance address

Rename delegate_call to library_call, and change the contract address argument to class hash.

Add a deploy system call.

Rename ContractDefinition to ContractClass

Reduce the compiled contract file’s size by removing unnecessary identifiers (this optimization can be disabled using --dont_filter_identifiers)

Initial support for the EC-op builtin (scalar multiplication over the STARK curve). Not supported in Starknet yet.

Add additional helper methods to blake2s.cairo, including big-endian support