Quicknode

March 20, 2024 — 5 min read

Quicknode now supports Starknet, a layer-2 network on Ethereum, that operates as a zero-knowledge rollup to bring security and efficiency to dApps. Starknet’s STARK proofs enable dApps and projects to achieve high performance at a fraction of the costs seen on layer-1 networks while improving Ethereum as a settlement layer.

This partnership allows developers and teams building on Starknet with Quicknode can ship faster and save resources. Quicknode’s developer toolkits do all the heavy lifting and help deploy ideas and solutions on Starknet that much sooner.

What is Starknet?

Starknet is a zero-knowledge rollup that bundles multiple transactions off-chain, reduces gas fees, and increases the throughput of Ethereum. It employs STARK (Scalable Transparent Argument of Knowledge) proofs for verifiable off-chain computation.

Additionally, Starknet has a purpose-built language called ‘Cairo’ which is optimized to generate STARK proofs. This allows developers to write complex smart contracts on Starknet without worrying about the zero-knowledge part. Cairo's syntax is similar to Rust's, making the language more familiar for developers.

How Starknet works — explained

Here is a quick breakdown of the working process of Starknet:

• Transactions are initially submitted to the Starknet gateway (mempool), marked as "RECEIVED."

• The sequencer collects transactions from the gateway, orders them, and creates a new block, marking transactions as "ACCEPTED_ON_L2."

• Prover executes the Starknet OS on the new block, applying state transitions from the transactions.

• STARK proofs are generated to verify the block's state transition validity without needing to recompute it.

• The STARK proof is submitted to Ethereum, where it's verified. Upon verification, the state root updates, finalizing the block.

This way, Starknet can process transactions off-chain, reducing computational effort and costs, while inheriting Ethereum’s security.

To make this possible, Starknet’s architecture involves three major components:

1. Sequencers are similar to Ethereum validators. They are responsible for receiving transactions, ordering them, and creating blocks. Sequencers enhance transaction capacity by batching and then forwarding blocks to provers.

2. Provers utilize Cairo's Virtual Machine to validate sequencers' work, generating STARK proofs for block validity. These proofs are then sent to Ethereum for final validation.

3. Nodes audit the network and help maintain state integrity through methods like transaction replay and L1 proof checks.

Why should developers build on Starknet?

Here are three reasons for developers to consider Starknet as their playground to build dApps:

• Scalability: Starknet addresses Ethereum's scalability challenges head-on, enabling developers to build dApps that process a high volume of transactions efficiently.

• Lower costs: Off-chain computation on Starknet significantly lowers gas fees compared to Ethereum's mainnet, making dApps more economical to use.

• Privacy by default: The use of zero-knowledge proofs offers a built-in privacy layer, allowing for the execution of transactions and smart contracts without revealing sensitive data.

Starknet is now supported by Quicknode

Quicknode is a leading blockchain tooling and infrastructure provider that streamlines your development and simplifies your backend.

Today, Quicknode is adding support to Starknet mainnet and testnet. A suite of tools from RPC nodes to APIs will be made available for developers building on Starknet.

Currently, Quicknode offers RPC services for Starknet — bridging blockchain with the application and removing the need for projects to run their own nodes.

Several Starknet APIs, including Node API, Trace API, Node Write API, and Pathfinder API, across both Testnet and Mainnet with WebSocket (WSS) and HTTPS protocols are supported by Quicknode. Requests from various programming languages (cURL, JavaScript, Python, Ruby) are being catered by Quicknode on Starknet.

Alongside, Starknet also has a plethora of developer tools made available for developers across the globe.

Start building on Starknet with Quicknode today

For Starknet, Quicknode is the premier solution for developers. Here are three reasons why:

1. Speed

Compared to other node providers, Quicknode is the fastest and most stable node provider. It houses an extensive and global network of nodes which helps in processing requests as close to the source as possible, contributing to quicker response times and low latency.

2. Reliability

Quicknode's network spans 14+ regions and multiple cloud & metal providers. Alongside, Quicknode operates multi-client setups across various blockchain protocols, optimizing for specific RPC calls. This approach guarantees consistent performance and reliability.

3. Scalability

Quicknode offers a global, auto-scaling, multi-node network that adapts to projects' needs and growth. It ensures the dApp or protocol remains performant regardless of user influx or activity. This way, Quicknode can support and serve indie developer projects and multi-billion dollar companies at the same time.

4. Support

Quicknode stands out for its dedicated support team. Developers receive personalized assistance, from troubleshooting to optimization advice. There’s also a huge community of developers on Discord who share learnings and help each other out.

5. Documentation

Quicknode offers comprehensive, state-of-the-art documentation for developers. From detailed guides to practical code examples to best practices of web3 development, Quicknode houses a library of vast documentation for developers.

Learn more about Starknet using the following resources:

• Starknet website

• Starknet official documentation

• The Starknet Book

• Starknet blog

• Developers blog

• Starknet research hub

Why Quicknode?

Quicknode makes blockchain infrastructure easy, freeing developers to focus on the dApps (decentralized applications) they’re building instead of everything that goes into running blockchain infrastructure, such as DevOps/NodeOps, uptime, scaling, security, tooling, etc...

By eliminating the headache of node maintenance & synchronization, and providing a comprehensive, end-to-end platform, we save developers valuable time getting a high-quality dApp to-market faster, and help businesses scale and execute their Web3 strategies.

Quicknode is an indispensable tool in a Web3 developer’s arsenal that was created by developers for developers, and battle-tested by industry-leading projects.

Today, the Quicknode network processes over 200 Billion requests per month across 35+ networks, in 14+ regions worldwide.‌‌

Visit Quicknode.com or check our Starknet guides section for more information.