As promised 0.12.0 was just the start of the Starknet Mainnet Quantum Leap!

We increased throughput massively and decreased latency to almost instant transactions.

Soon we move 0.12.1 to Testnet.

This is the 2nd stage of the Starknet Mainnet Quantum Leap.

Read on: ⏬🔽

The 0.12.1 upgrade specifically aims to improve the user experience and ensure reliable transactions, ultimately enhancing devs' interactions with the system.

With the introduction of 0.12.1. failed transactions will be included in blocks, which previously caused inconvenience for devs who had to constantly monitor their transaction status before initiating new ones.

This upgrade resolves this issue and simplifies transaction management for devs.

An important feature of this upgrade is the implementation of charges for failed transactions, a change from the previous version where users were not charged for unsuccessful or reverted transactions.

This change is expected to protect the network from potential spamming with invalid transactions.

Previously a significant portion of the sequencers workload consisted of processing transactions that ultimately did not make it into blocks often accounting for over 50%.

By implementing charges for failed transactions in version 0.12.1 it is expected that better script management will be incentivized and unnecessary workload on the sequencer will be reduced.

This awesome upgrade also lays the ground for even more transaction processing speed and overall network health, which will result in more TPS and sky high numbers on L2beat.

Looking ahead into Q4 updates such as versions 0.13 and 0.14 will bring further enhancements like "Volition" and 4844 leading to substantial reductions in transaction fees and introducing a fee market.

If you have not upgraded your wallet accounts in the past 6 months, you have another chance to do so until the 0.12.1 upgrade hits mainnet.

https://twitter.com/Starknet/status/1637740811096846336?s=20

Starknet Mainnet Quantum Leap: 0.12.1 Upgrade

Dojo is a provable on-chain game engine.

Ok slow down, wdym??!!

"On-chain" means that all of its actions occur on the blockchain, while "provable" refers to using cryptographic methods to confirm that the actions have taken place as desired.
“Engine” means that you don't have to start from scratch.

Plug your ideas into the engine and ship it.

The engine operates on Starknet, "*the*" L2 Validity Rollup (aka ZK-rollup).

Starknet enables high TPS rates at minimal costs with Ethereum security.

@dojostarknet resolves several challenges and brings us closer to Autonomous Worlds.

Lets look under the hood of Dojo:

Web2 Gamers hate crypto games because these are clunky and sometimes just money grabs.

Dojo brings seeeaaaamless, 8K gaming.

By operating on Starknet over Ethereum, Dojo can take advantage of high transaction throughput, low costs, and unstoppable decentralization.

This allows for computation-hungry gaming use-cases that wouldn't be possible on a traditional blockchain setup.

Dojo provides a software framework for game devs. It has tools and libraries that prevent devs from having to build everything from scratch (such as physics, graphics, and game mechanics), similar to how traditional game engines like Unity and Unreal Engine work.

This significantly reduces the budling time and complexity of creating crypto games. Spin up your autonomous world within a hackathon and win all sweet fame.

This is already very helpful but there is more. Dojo is a provable game engine.

This means the logic of the game can be proven and verified on-chain, which is essential for the trustless nature of what we are all buidling here otherwise you could run your game on an SQL server which is way faster and cheaper than any unstoppable setup.

Yes you own your bags.

Dojo supports the key concepts of crypto gaming: ownership of in-game assets and interoperability.

These features mean that the assets gamers earn or create in a game truly belong to them and can be used or transferred into other apps or games, creating a multiverse of interconnected games.

With components like ECS (Entity Component System), Sozu, Torii, and Katana, Dojo has the perks of modularity, efficiency, and flexibility.

This allows for the creation of complex, dynamic games on the chain while still taking advantage of the decentralized and transparent benefits of Ethereum.

In short, Dojo brings the benefits of Ethereum and Starknet to the gaming world.

Have a crazy gaming idea? Jump into the Dojo and ship it!

Dojo: A Provable On-Chain Game Engine

With the Starknet Mainnet Quantum Leap, we have made remarkable progress in terms of scalability, security, and throughput within the Ethereum ecosystem.

We've also solved a significant challenge with our partners: user experience (UX).

Here's how Account Abstraction works:

Self-custodial wallets can be intimidating to use. These wallets must be secured. It is often the first point of contact for new cryptocurrency users.

Our solutions need to be more approachable, secure, and adaptable.

Smart Accounts are!

Account Abstraction (AA) presents the path forward for Smart Accounts.

AA facilitates the development of contracts for individual accounts allowing us to move away from the inflexible reliance on private keys.

This is the UX enhancement we need for self custody wallets.

Presently Ethereum offers two types of accounts: Externally Owned Accounts (EOAs) and Contract Accounts (CAs).

AA seeks to separate the authorization logic from EOAs effectively transforming each account into a contract.

The implementation of AA opens doors to a plethora of features such, as Hardware Signers, Paymasters, Social Recovery, Multifactor Authentication, Quantum Resistant techniques and Gas Efficient Signatures.

These features can be also be tailored and combined and this is augmenting security and accessibility.

Starknet, is a sleeping giant, we have integrated native AA from the inception.

With native smart accounts no one needs a new role of bundlers, as there is no separation between transactions and user operations.

What sets Starknet apart in our approach to account architecture, all accounts are treated as first-class citizens.

This unique flexibility allows for the implementation of features like leveraging phone hardware for transaction signing, incorporating guardians for added account security and integrated 2FA.

The recent Starknet alpha V0.12.0 update, developed in collaboration, with @class_lambda has significantly increased its throughput by ten times.

This impressive enhancement provides the platform with the power needed to fuel real world applications.

Notably the upgraded version of the Starknet Mainnet now operates at a rate of 220K Cairo steps per second (CSPS) a big improvement compared to the previous average of 30K CSPS.

This significant boost in throughput dramatically reduces transaction waiting times and resolves network congestion issues. Next up is cost reduction by up to 85%.

Ultimately enhances the user experience further.

Starknets advancements are empowering wallets such as @myBraavos and @argentHQ offering improved user experience, enhanced security measures, and increased throughput.

Imagine the ease of using hardware signers, paymasters, 2FA and social recovery.

The possibilities that arise from leveraging Starknet are endless

Imajjin the creation of a contract that enables users to set up subscription services with auto payments— to popular services like Netflix, Twitter, Spotify etc.

The versatility of Starknet truly opens up avenues, for innovation, creativity and convenience.

To sum this up, we truly believe that Account Abstraction is the key to good UX by replacing rigid, protocol-level behaviors with flexible, programmable smart contracts.

We use this tech by default, it gives account security, simplifies txn, and allows for personalized features plus signature, fee, and nonce abstraction, this enables customized verification logic, fee payments, and replay protection.

That's it, this is the magic you need!

The infrastructure is ready! Lets build the dApps!



Enhancing Ethereum: Starknet Mainnet Quantum Leap and User-Friendly Account Abstraction

What a week, everyone is BACK!

The Starknet Quantum Leap Mainnet Launch is a big success. Transaction times decreased to low single-digit numbas and TPS peaks are already at record levels.

Some insights on why we're not seeing such rates consistently throughout the day. Dive ⏬

Starknet's full TPS performance is currently throttled but these are just the current constraints & we're working to remove them & wake the beast! 🦍 🐺 🐉

When the txs queue builds up, and the Sequencer clears at its full capacity we can already observe peak TPS rates at record levels but it’s not a sustainable rate for the whole day because the TPS performance of Starknet is also tightly correlated with demand.

Currently, our network is not operating at full capacity as the demand is yet to catch up with our new infra.

But with all the beautiful dApps budling on Starknet, we're sure to see these numbers rise soon.

Come build and break things! 0.12.1 is also ready in a couple of weeks.

On the public Goerli testnet, with artificially increased demand, we made nice observations about Starknet's performance.

Ser Jorik spills great alpha here: https://twitter.com/mempoolsurfer/status/1679497834289147907?s=20

From a previous 13k Cairo steps per second, we hit a whopping 890k! That's a 68x speedup, flexing Starknets scalability power.

As we work to remove throttling step by step this summer, we anticipate seeing a further rise in performance.

The capacity of the infra is here and the ecosystem devs will ship nice dApps for our social layer.

Stay tuned for moooar!

Starknet's potential is a sleeping giant, and we're about to wake it up!

Starknet Mainnet Launch: A Quantum Leap in Performance

Yeah 0.12.0 is nice but its just the start.

The fam is set to release version 0.12.1 this August aka the 2nd stage of the Starknet Mainnet Quantum Leap.

What does it mean besides even moar TPS?

Read on: ⏬🔽🔽⏬⏬

This upgrade is specifically aimed at improving the user experience and ensuring reliable transactions ultimately enhancing devs' interactions with the system.

This awesome upgrade also lays the ground for even mooar transaction processing speed and overall network health, which will result in more TPS dddddda.. and sky high numbas on L2beat.

Looking ahead into Q4 updates such as versions 0.13 and 0.14 will bring further enhancements like "Volition" and 4844 leading to substantial reductions in transaction fees and introducing a fee market.

So long, stay tune, hydrated and see you in Paris. 🍷🍷🚬🚬

Starknet 0.12.1: Enhancing User Experience and Reliable Transactions

We are excited to announce that Starknet Quantum Leap part 1: v0.12.0 has been successfully deployed on the Mainnet.

This update is a significant milestone in improving Ethereums capacity.

As it has allowed us to increase the networks throughput tenfold. Significant improvements have been made to our Sequencer.

One of the major enhancements is the integration of Cairo rs, which is a highly efficient Cairo runner developed by @class_lambda in Rust.

This integration has greatly improved the execution of Cairo contracts. Resulting in a better user experience.

Moreover, our @StarkWareLtd  team has introduced the Blockifier, a Rust based block execution logic that plays a vital role in enhancing throughput. By optimizing transaction execution times.

We have successfully reduced wait times and alleviated network congestion.

Another key contributor to these remarkable improvements is Papyrus, our local storage solution. Papyrus plays a crucial role in managing the Sequencers local state.

Ensuring overall system performance and responsiveness are optimized.

But Ser, we are just getting started. The recent Sequencer optimizations included in the current version mark just the beginning of our journey towards achieving further performance improvements.

Our next step involves integrating @class_lambdas' cairo_native compiler.

This exciting integration will enable us to execute Cairo contracts even more efficiently.

By allowing contracts to run as "native code" similar to Rust. Rather than within the Cairo environment.

We shipped also UX improvements. Enhancing user experience has always been one of our priorities, which is why we have eliminated the 'PENDING' status and introduced the new 'ACCEPTED_ON_L2' status.

This change provides finality and reduces confusion for users.

In addition our alpha v0.12.0 release introduces a new Cairo syntax that enhances safety and supports a new syscall called get_block_hash making it easier for users to retrieve past block hashes. However. Our journey does not end here.

As mentioned severl times, v0.12.0 is only our first step in this Quantum Leap.

In the coming weeks, we're looking forward to implementing and testing Starknet 0.12.1, the second part of our Mainnet Quantum Leap.

In this release, we're taking an important step towards improving network efficiency: failed transactions will now incur fees, discouraging wasteful attempts and maintaining optimal network performance.

Our mid term roadmap includes the development of various features to address challenges such as storage, which currently accounts for over 90% of Starknet transaction costs. In response to this challenge.

We will introduce Volition in Starknet 0.13.  Giving dApp developers the ability to choose their desired security level for contract storage.

Developers can opt for storing data either on Ethereum at a higher cost or on Starknet at a more affordable price point.

To ensure its readiness and stability Volition will undergo thorough testing on the testnet before its launch date.

We are also eagerly anticipating EIP4844s' release on the Ethereum mainnet as we plan to promptly adopt it to reduce the cost of Starknet on chain data.

Looking a bit further ahead into Q4. Starknet 0.14 will introduce a fee market for transactions conducted on Starknet.

This will involve a shift from our current fixed gas price per block system to a first come first served transaction processing system.

We also have plans to reintroduce parallel transactions. A feature that was temporarily removed in the 0.12 release due to the superior performance of the new Rust engine compared to the older Python engine even without them.

These parallel transactions, with further improvements will enhance throughput.

We very much appreciate your continued support as our journey progresses. Stay tuned for more updates in the short future!

To learn more about the STARK quantum leap update please refer to this bloag

https://starkware.co/resource/starknet-quantum-leap-major-throughput-improvements-are-here/

Starknet Quantum Leap: Enhancing Ethereum's Capacity

Dive headfirst into the exhilarating world of zk-STARKs, led by none other than our resident STARK Maxi and tech wizard, @EliBenSasson, in this Basecamp Cohort 4 masterclass mc'd by @barretodavid

🧵
https://www.youtube.com/watch?v=jg9KSNOO2XY

Charge up your neurons as we chart a course through the electrifying mathematical core of zk-STARKs, a tech revolution in the making.

This masterclass is your gateway to:

🧮 Finite Field Arithmetic: Unravel the intricacies of finite fields and their vital role in the mesmerizing choreography of zk-STARKs.

🚀 Low Degree Extensions: Stand in awe of the power wielded by low-degree extensions, the behind-the-scenes architects of sleek, scalable zero-knowledge validity proofs.

🔐 Commitments: Embark on a journey through the enigmatic maze of cryptographic commitments, the unsung protectors of data integrity within zk-STARKs.

🧩 Polynomial Constraints: Grapple with the integral function of polynomial constraints, the magic ingredient enabling the creation of succinct, efficient proofs.

📡 FRI Protocol: Decode the enigma of the Fast Reed-Solomon Interactive Oracle Proof of Proximity (FRI) protocol, a keystone in the zk-STARK architecture.

Whether you're a crypto junkie, a blockchain code slinger, a math whizz, or a zk-STARK explorer, this masterclass is your golden ticket to the big leagues, straight from a pioneer in the field.

📚 Quick Dips Reading List:

@EliBenSasson endorses the STARK series from StarkWare's Medium account as your essential guide to the zk-STARK universe.

A perfect launchpad for those racing against time:

• STARK Math: The Journey Begins medium.com/starkware/stark-math-the-journey-begins-51bd2b063c71

• Arithmetization I & II medium.com/starkware/arithmetization-i-15c046390862, medium.com/starkware/arithmetization-ii-403c3b3f4355

• Low Degree Testing medium.com/starkware/low-degree-testing-f7614f5172db

• A Framework for Efficient STARKs medium.com/starkware/a-framework-for-efficient-starks-19608ba06fbe

10/ Dive deep, let these insightful pieces be your beacon in the vast ocean of zk-STARKs.

Dive into zk-STARKs: A Masterclass Journey

Starknet Quantum Leap  Throughput just skyrocketed!

Alpha V0.12.0 hits the testnet with a bang! 💥💪

We proudly announce that Starknet alpha V0.12.0 has been successfully launched on the testnet.

Shattering the barriers to TPS and achieving a significant milestone in performance and scalability.

Vibe with us, as we are committed to making crypto nation faster. More efficient. And seamlessly accessible to all! 🐉⚡

In collab with the fam @class_lambda! We have taken Starknets throughput to an unprecedented level of growth -> improving it by an astonishing tenfold!

Lets' dive into this formidable enhancement! Lets get rusty!

By implementing the Starknet Sequencer in Rust we have transformed it into an absolute speed demon that governs throughput limits.

With significant advancements made in its performance we have effectively unlocked the gates for increased transaction capacity.

Yay more TPS daddy  👈👉

Thanks to the super dragon powers of Rust. The fam has supercharged the Sequencers efficiency levels!

Through our integration of Cairo rs and introduction of the magic Blockifier -> the max powerful Rust-based block execution logic <- we have successfully optimized transaction execution time while reducing snail times and freeing up network traffic congestion.

And yus, we are just getting started. Our heads are still down budling to enhance contract execution on Starknet.

We will soon ship LambdaClasss' cairo_native compiler, a secret move that promises even greater efficiency gains during Cairo contract execution.

With Rust breathing mode expect remarkable attack advancements in terms of performance 🔥🌪️🔥

We also simplify your crypto journey with no more 'PENDING' transactions, only 'ACCEPTED_ON_L2' finality.

Now devs can swiftly retrieve specific block hashes via the new get_block_hash syscall, boosting cross-chain trust & efficiency. Sounds smool, is biig!

Also a smoll new Cairo syntax tune, which puts a strong focus on safety. With this update, devs can expect a better interaction with the contract.

Upcoming versions will include an extensibility feature that allows contracts to use components from external libs

Our short term summer goals revolve around enhancing UX and transaction reliability.

The next version, 0.12.1 will solve UX problems for devs by including failed transactions in the block and protect the Sequencer from system spam.

Looking towards the future. Our long term vision is to achieve even much more throughput. Minimize latency. And reduce transaction costs massively.

We are committed to making transactions max affordable and inclusive.

Its all about empowering a broader range of innovative use cases.

True decentralized applications here we come!


Anon, your opinion matters!

Join us in voting for Starknet Alpha V0.12.0 during our live community vote.

We want widespread participation and input from everyone involved.

Come and be part of shaping the future of Startnet by voicing your thoughts through voting (become a delegate and vote with the delegated token voting rights) and discussions on our Community forum. https://community.starknet.io/t/proposal-starknet-alpha-v0-12-0/95997

Super Saiyan devs! This is your time to code solutions that make a difference.

Start with Cairo now, now, now, now, now, now!! you will not regret it, its easy to learn! Read our docs. Registering for Cairo Basecamp. Or go through the tutos. https://book.cairo-lang.org/

Again, big kudddos to @class_lambda! Their contributions have been invaluable in enhancing Starknets performance.

With their deep mental models in distributed systems, compilers, machine learning, and cybersecurity. They are truly pushing the boundaries.

Dare to dream! 🎈🔭💭

Starknet Alpha V0.12.0: A Quantum Leap in Throughput

The Starknet Mainnet Quantum Leap is a breakthrough in scaling Ethereum!

Devs are expanding their skills to include the easy to learn Cairo.

Solidity is a well-known smart contract language, but why tf are devs moving to Cairo???

Simple.. we explain. 👇

Solidity made global interoperable smart contracts possible, but it had one big downside: it required a lot of repetition.

Cairo, on the other hand, creates verifiable transaction execution proofs with just one machine.

Both Cairo and Solidity are smart contract languages, but their functionalities and principles are distinct.

Think of them as different tools in your dev toolbox.

Cairo's popularity is skyrocketing.

The number of full-time devs increased by 875% over the past two years and by 83% YoY. It's not just for crypto - any situation requiring proof of computation can benefit from Cairo.

So, what is Cairo? 🚁

It’s the Rust-inspired, native smart contract language for Starknet.

It's the first Turing-complete language for STARK-provable programs that can be verified by any independent verifier.

Is Cairo better than Solidity?  = apples to oranges 🍏🍊

Imagine Solidity as a Lego set where you can take different building blocks (crypto components) and put them together in numerous ways to create a complex lego space station (a complicated smart contract).

It's all about putting together different smaller modules to create something bigger which interacts with each other.

On the other hand, Cairo has a very unique and powerful property: it creates provable programs for general computation.

But what does that mean?

Imagine you want to check if someone has put the complex lego space station correctly together.

With Solidity, you would need to check each lego piece and its position. You basically have to redo everything.

With Cairo, you can see exactly if each step is done correctly, you just have to check the "proofs of correct execution" This makes Cairo very efficient!

Transitioning from Solidity to Cairo means understanding some key differences.

Cairo's VM uses a single-write-only memory model, and the base for all its operations are field elements, unlike the EVM which uses conventional uint256 or uint32 systems.

Remember, Cairo doesn't have the concepts of inheritance and polymorphism.

While contracts can be extended, object-oriented programming concepts require some innovative thinking.

It's important to note that Cairo smart contracts are converted into Sierra code first, which adds a security layer to avoid DoS attacks.

To sum up, Cairo isn’t better or worse than Solidity, just different.

It’s a powerful tool for devs looking to streamline their computations and work more efficiently.

As we enter the broadband moment in crypto, having options is a good thing!

To benefit from the power and scalability of STARKs, learn the open-souce language Cairo and write your programs in that way.

The Rise of Cairo in Smart Contract Development

Next week, the Starknet public testnet will be upgraded to 0.12.0.

The start of the Quantum Leap!  👉👈

But wdym??!!!

The Starknet roadmap prioritizes performance and user experience (UX) as its main focus, in response to clear feedback from the ecosystem.

read on

Until now, Starknet has concentrated on offering devs future-proof functionality, with Cairo 1.0 signifying the stabilization of this development.


With performance and UX as the current focus, Starknet's timeline is as follows:





Today the primary goal is to improve network performance to support the anticipated growth in users and devs.

Starknet v0.12.0 was now on integration for some time and will move next week to the public testnet.

Starknet v0.12.0 will offer significant throughput and latency enhancements, thanks to six months of work on Rust-ifying the Starknet stack, dramatically reducing block execution time and increasing throughput.

Version 0.12.1 will include a crucial update: failed transactions will be included in the block, fixing UX issues and protecting the sequencer from spam, ultimately providing a more seamless user interaction.


Starknet v0.13.0 will drastically cut transaction costs by targeting L1 (Ethereum) data cost, which represents 95% of current transaction costs.

Ethereum's EIP-4844 and Starknet's Volition (off-chain data availability) will contribute to significant data cost reductions.


To address potential congestion issues, Starknet v0.14.0 will introduce a fee market, allowing efficient allocation of the network's limited resources.


In v0.15.0, Starknet will transition to constant, shorter block intervals by decoupling the 1:1 relationship between a Starknet block and its proof.

From v0.15.0, a proof will attest to the integrity of one or more Starknet blocks, fixing block intervals and enhancing UX.


The combination of future-proof functionality and best-in-class performance and UX improvements is expected to continue attracting devs and dApps to Starknet.

Do you have any question irt this update?

Let us know, we read every comment, we also appreciate memes 👉 👈