Starknet

starknet

Happy 2025 Hackers! We are kicking off the new year with another edition of Company of the Week! Every week, we introduce a prominent tech enterprise from our tech company database, in an effort to recognize their impact on the industry. This comprehensive database ranks S&P 500 companies alongside the most innovative startups of the year, presenting a diverse range of industry excellence. This week, we present Starknet, a ZK-Rollup leveraging the STARK cryptographic proof system. Being a Layer 2 network on Ethereum, Starknet enables dApps to scale computationally without compromising security or composability. It leverages the highly scalable STARK cryptographic proof system for unmatched efficiency. StarkNet Contracts and its OS are built in Cairo, a language designed for flexible, scalable deployment. This ensures support for diverse use cases across industries. Request your own Tech Company News Page on HackerNoon Meet Starknet: Fun Facts StarkNet strongly prioritizes building a vibrant community, understanding the importance of establishing trust and fostering loyalty among supporters and adopters. To facilitate this, the company has developed a dedicated forum that serves as the hub for members to stay informed about product updates, discuss policies, address challenges, and contribute ideas for enhancements. Additionally, Starknet has hosted many events worldwide, ranging from community engagement and hackathons to social meetups. These events provide developers and enthusiasts an open, creative playground to connect with like-minded individuals. Starknet 🤝 HackerNoon Targeted Ads Campaign Starknet has recently partnered with HackerNoon to drive attention to its Starknet Basecamp program—a free training program that provides essential foundational knowledge to help participants get started with Starknet and Cairo. Multiple cohorts are hosted worldwide, in different languages across different time zones. The sessions not only fulfill Starknet’s mission of community engagement but also foster inclusivity and the proliferation of knowledge among the developer community. Check out ongoing Starknet Basecamp cohorts available here Do it like Starknet - Learn How You Can Advertise to Your Specific Niche on HackerNoon That's all this week, folks! Stay Creative, Stay Iconic. The HackerNoon Team Happy 2025 Hackers! We are kicking off the new year with another edition of Company of the Week ! Every week, we introduce a prominent tech enterprise from our tech company database , in an effort to recognize their impact on the industry. This comprehensive database ranks S&P 500 companies alongside the most innovative startups of the year , presenting a diverse range of industry excellence. Company of the Week Company of the Week tech company database tech company database S&P 500 companies most innovative startups of the year This week, we present Starknet , a ZK-Rollup leveraging the STARK cryptographic proof system. Being a Layer 2 network on Ethereum, Starknet enables dApps to scale computationally without compromising security or composability. It leverages the highly scalable STARK cryptographic proof system for unmatched efficiency. StarkNet Contracts and its OS are built in Cairo, a language designed for flexible, scalable deployment. This ensures support for diverse use cases across industries. Starknet Request your own Tech Company News Page on HackerNoon Request your own Tech Company News Page on HackerNoon Request your own Tech Company News Page on HackerNoon Request your own Tech Company News Page on HackerNoon Meet Starknet: Fun Facts StarkNet strongly prioritizes building a vibrant community, understanding the importance of establishing trust and fostering loyalty among supporters and adopters. To facilitate this, the company has developed a dedicated forum that serves as the hub for members to stay informed about product updates, discuss policies, address challenges, and contribute ideas for enhancements. StarkNet a dedicated forum Additionally, Starknet has hosted many events worldwide , ranging from community engagement and hackathons to social meetups. These events provide developers and enthusiasts an open, creative playground to connect with like-minded individuals. events worldwide Starknet 🤝 HackerNoon Targeted Ads Campaign Starknet has recently partnered with HackerNoon to drive attention to its Starknet Basecamp program— a free training program that provides essential foundational knowledge to help participants get started with Starknet and Cairo. Multiple cohorts are hosted worldwide, in different languages across different time zones. The sessions not only fulfill Starknet’s mission of community engagement but also foster inclusivity and the proliferation of knowledge among the developer community. Starknet Starknet Basecamp program— Check out ongoing Starknet Basecamp cohorts available here Check out ongoing Starknet Basecamp cohorts available here here here here Do it like Starknet - Learn How You Can Advertise to Your Specific Niche on HackerNoon Do it like Starknet - Learn How You Can Advertise to Your Specific Niche on HackerNoon Do it like Starknet - Learn How You Can Advertise to Your Specific Niche on HackerNoon Do it like Starknet - Learn How You Can Advertise to Your Specific Niche on HackerNoon Starknet Learn How You Can Advertise to Your Specific Niche on HackerNoon That's all this week, folks! That's all this week, folks! Stay Creative, Stay Iconic. Stay Creative, Stay Iconic. The HackerNoon Team The HackerNoon Team

Meet Starknet: HackerNoon Company of the Week

Unpacking The Starknet Bolt Upgrade

የስታርክኔት ቦልት ማሻሻያውን በማራገፍ ላይ

Разопаковане на Starknet Bolt Upgrade

Desembalaje de la actualización Starknet Bolt

Déballage de la mise à niveau Starknet Bolt

Debalaj Starknet Bolt Upgrade a

Disimballaggio dell'aggiornamento del bullone Starknet

Starknet Bolt アップグレードの開梱

Starknet Bolt-ის განახლება

Starknet Bolt jauninājuma izpakošana

Kufungua Uboreshaji wa Starknet Bolt

Кушодани навсозии Starknet Bolt

Starknet Bolt yangilanishini ochish

Understanding Maximal Extractable Value on Starknet

The entire market sentiment in December was dominated by the wealth effect, with ORDI’s thousandfold increase in active Inscription. A hundredfold increase was driven by $MOBILE in the DePIN. The Starknet airdrop plan has been continuously mentioned since the beginning of the month. The first two experienced explosions after a long period of silence; Starknet, on the other hand, was already hailed as an L2 star project alongside Arbitrum, Optimism, and zkSync a year ago: Raised $260 million with a valuation of $8 billion; TVL surpassed the $100 million mark, attracting an increasing number of users. Combined with the Optimism airdrop in June last year and the Arbitrum airdrop in March, which brought case after case of financial freedom, people’s expectations for the Starknet airdrop are at an all-time high. On December 1st, the Starknet Foundation announced that they had taken a snapshot for the airdrop and would distribute STRK tokens to past active users and contributors in the first quarter of 2024, unlocking previously distributed tokens. Early entrants are marking their calendars, eagerly awaiting the drawing; some are concerned that their interaction depth may not be enough to receive a substantial airdrop, and there are those who haven’t participated at all. Can outsiders only silently observe the celebration of others? Although Starknet has finalized the snapshot, most of the protocols on Starknet have not yet disclosed their airdrop plans. Based on past experience, most projects on these star ecosystems are likely to issue their own tokens. For example, Astraly, the token distribution platform on Starknet, has explicitly mentioned future airdrop plans in community responses: Official Support + Star Effect Starknet strongly supports projects in its own ecosystem: “Devonomics Pilot Program”: This program will distribute 10% of all transaction operator fees to developers building on Starknet since its launch in November of last year, totaling 1600 ETH. Of this, 8% will be allocated to dApp developers, providing 1280 ETH, and 2% will be allocated to core developers, providing 320 ETH. In the future, allocations will switch to using the Starknet token STRK. With official support and the star effect of Starknet itself, there are countless projects in the ecosystem: How do you find Alpha projects? Projects in the official recommended list have a basic guarantee of quality. However, referring to Starknet’s recommended page, even The Best Starknet Dapps recommended by the official has nearly 100 projects. The time and effort required for interaction with 100 projects are relatively high. How to quickly experience these projects? Solution: task platforms. For projects in need of growth, active project parties will choose to release activities through task platforms to attract users. Compared to well-established Web2 task platforms like Gleam, more and more Web3 platforms are widely adopted because they support the release of on-chain tasks. How extensive is the coverage of these Web3 task platforms? Referring to the recommended cross-chain bridge projects on the Starknet official page, it can be seen that the project coverage on task platforms is relatively high. Although not complete, one website can understand the most recommended projects and directly participate in project activities, saving a lot of time and effort. The wealth effect dominated the entire market sentiment in December. In Galxe, TaskOn, and similar platforms, the main purpose of launching activities is to attract users, so the threshold for tasks is relatively low and easy to complete. Common task configurations include following social media, joining communities, and completing PoW tasks or entry-level on-chain tasks to help users quickly familiarize themselves with the product. For understanding a project, this is the best start. The rewards for these activities are also diverse, including NFTs, whitelist spots, stablecoins, Discord roles, etc. Platforms like Galxe OAT and TaskOn’s CAP offer official NFT credentials, serving as on-chain proof of a user’s contribution to a project’s activity. While you may not become an early participant in the Starknet ecosystem, you can still be an early user of these applications. Starting with task platforms, you can quickly find your Alpha project. Also published . here

Starknet's Astronomical Rise and Potential Airdrop Opportunities with the Starknet Eco

StarkNet is a solution that utilizes to scale Ethereum. It alleviates Ethereum’s network congestion by increasing the throughput and reducing the transaction fee. Availing the zero-knowledge proof technology, it also enhances data security and privacy. Layer2 zkSTARKs With StarkNet, developers can build, deploy, and run high-performing smart contracts in a decentralized environment without worrying about pricey transaction fees and the security of smart contracts. These features make it especially suitable for building dApps that require high performance and low transaction fees like those in DeFi, NFT, or GameFi. The StarkNet ecosystem also opens a lot of new possibilities for developers. Leveraging the flexibility and advanced features of the Cairo language, and taking advantage of StarkNet’s high throughput and customizability, developers can build innovative, high-performance, customized dApps on StarkNet. There are also many choices of zkEVM projects in the ecosystem, enabling developers to deploy and run smart contracts in safer and more efficient environments. All of these have contributed to the StarkNet ecosystem’s significant growth lately with a notable increase in its total value locked. In this article, we’ll look at the advantageous features of StarkNet, share the innovative projects in the ecosystem, and explore the challenges and future prospects the ecosystem may face. StarkNet’s Advantageous Features has many unique advantages offered by using zkSTARKs, the native programming language Cairo and the Cairo Virtual Machine (VM). Its custom development environment enables higher performance, better security, and richer features. Developers can write secure and reliable smart contracts in Cairo and enjoy the high throughput realized by StarkNet via its STARKs-based validation mechanism. Although there is a learning curve for developers, the effort will be well compensated. StarkNet StarkNet employs its own custom programming language Cairo and implements the Cairo VM. This approach is very different from other layer2 solutions which leverage the existing components of Ethereum. While most other solutions focus their effort on Ethereum-oriented optimizations, StarkWare concentrates on polishing its own stack for its ecosystem. Although it sacrifices the network effect of being fully compatible with Ethereum, it’s hard to refute that this choice is reasonable, especially considering it has achieved a network effect around Cairo and the escape velocity needed to expand. In its future development, these technological features and innovations will provide ongoing value. With the increasing importance of data security and privacy, the robust privacy-preserving capability that StarNet offers will be able to attract more users and applications to the network. At the same time, StarkNet’s scalability and decentralized nature make it an effective solution for addressing high throughput and security requirements. As the blockchain ecosystem develops and the demand grows, StarkNet’s superior technological features in terms of throughput, security, and privacy protection will provide significant value to its business, enabling it to win out in the competition. Various Projects in the Ecosystem At the core of StarkNet’s dApp ecosystem is its capability for building zero-knowledge-proof based highly performant, low-fee, privacy-preserving decentralized applications. While StarkNet enables various use cases, its advantages of high throughput, low fee, and privacy protection make it especially suitable for areas such as decentralized exchanges (DEXes) and NFT marketplaces. Below are some projects in the ecosystem that we believe are worth paying attention to. DeFi: JediSwap is a permissionless and composable AMM built on Starknet by the Mesh Finance community. The project has launched on Starknet mainnet, with a current Total Value Locked (TVL) of approximately $5 million. They also received a grant of 150,000 STARK tokens from StarkWare. JediSwap is very innovative, enabling lightning-fast, near-gasless exchange of assets in a trustless manner. It has already gained some market influence and is a contribution to the StarkNet ecosystem in DeFi. Morphine is an innovative DeFi lending and borrowing protocol with two primary use cases: passive lending and active borrowing. Passive lending allows users to provide liquidity and earn yields through junior and senior tranches, catering to different risk appetites. Active borrowing, on the other hand, enables users to deploy sub-accounts, in which they can borrow up to 15 times their collaterals, have access to LSD, LP, ERC4626, and set automation. Globally, Morphine is highly innovative, offering versatile strategies and functionalities for both lenders and borrowers. Its flexibility and degree of automation should be attractive to DeFi users. Therefore, we believe it has the potential to succeed. Orbiter Finance is a decentralized cross-rollup bridge for transferring the Ethereum native assets. The Orbiter Bridge infrastructure allows for fast and cost-effective transfers of Ethereum-based assets across various rollups like StarkNet, zkSync, etc. The team is also developing zkProver, a middle layer that utilizes zero-knowledge technology to aggregate transactions and increase the TPS and volume of cross-rollup transactions. The project will be able to contribute to StarkNet’s development by enhancing interoperability and scalability. DeversiFi is a decentralized exchange aiming to achieve faster and more secure trading through StarkNet while maintaining connectivity to Ethereum. NFT/Gaming/Metaverse: Realms (Bibliotheca DAO) started out as a Loot project and has evolved into a large-scale multiplayer blockchain game on StarkNet. The project scored 15 out of 18 by the Starknet Foundation and will receive a total of 150,000 $STRK from the Early Adopter Grant. RYG.Labs is an NFT creative agency focusing on building interactive dynamic NFTs and providing NFT marketing solutions. It will serve as a launchpad for artists entering the NFT field and promote the development of the NFT market on StarkNet. The Ninth is a metaverse game on StarkNet offering diverse gameplay such as land purchases and upgrades as well as staking. It balances the fun and integration of tech in gaming, using StarkNet ZK Rollup to secure the overall experience. It will contribute to the ecosystem in Metaverse and gaming. Other Innovative Web3 Projects: Argent X is the first wallet for StarkNet built by Argent. Utilizing native account abstraction on StarkNet, Argent X gives users peace of mind with multisig security and no seed phrase and achieves lower transaction fees and faster confirmation times. Braavos is a friendly smart contract-based self-custodial wallet built on StarkNet. It’s designed to offer a seamless experience for Web2 users and is currently available on Android, iOS, Chrome, Firefox, and many other browsers. Carbonable is a StarkNet-based system to track carbon contributions. It has completed the seed funding round with the participation of multiple venture capital firms. Its innovative blockchain-based approach helps reduce carbon dioxide emissions and achieve carbon neutrality. It will create a real-world impact on environmental protection and sustainable development, which will in turn be beneficial to the StarkNet ecosystem. Dolven Labs is a DAO Based Ecosystem Catalyst and a hub for permissionless DeFi tools and innovative projects for the StarkNet ecosystem. The team is also the builder of projects like StarkNet Social and StarkGuardians. Dolven Labs plays a vital role in the StarkNet ecosystem, offering projects accelerator programs and a suite of permissionless tools to allow them to expand their boundaries and achieve their goals. Herodotus is building storage-proof cross-chain data access solutions. It will allow smart contracts deployed on Starknet to access current and historical Ethereum on-chain data in a trustless manner. Herodotus’ solution will be important for increasing interoperability between Ethereum and StarkNet. It will help expand StarkNet’s capabilities and enhance the data accessibility of the blockchain ecosystem as a whole. Overall, the success of the StarkNet ecosystem so far lies in its technological advantages, developer support, and ecosystem support for various use cases. For StarkNet to further grow, extensive community support is needed. If it can attract the attention and support of more developers, investors, and users, it will have a better prospect. Challenges and Future Prospects One of the top challenges and bottlenecks that the StarkNet ecosystem may face is competition. Many other layer2 scaling solutions in the market are striving to compete with StarNet and they are more advantageous in some respects than StarkNet. Therefore, continuous innovation and improvements are needed to attract more developers and users. A second potential issue is the network effect. As StarkNet is a relatively new technology, it requires a significant influx of developers and users to establish a strong network effect. Effective marketing and promotion efforts are thus necessary. Another challenge that StarkNet faces is ensuring the sustainability of its ecosystem. With the emergence of competitors and technological advancements, StarkNet needs to continuously innovate and provide attractive features to maintain user loyalty and attractiveness. Additionally, StarkNet needs to establish solid relationships with developers and partners to foster ecosystem development and growth. Other challenges StarNet might face include: Since Cairo is a new language, developers need to learn and adapt to this new programming language. This may pose an additional learning curve for many developers, limiting their ability to participate in the StarkNet ecosystem. In contrast, Ethereum’s EVM has a larger developer community, making it easier for developers to get started and rapidly build applications. Adoption may be limited by the use of the Cairo language. Although StarkNet demonstrates the advantages of high throughput and low transaction fees in some use cases, these advantages may not be relevant for all application scenarios. For certain applications, especially those that don’t require processing a large volume of transactions, these advantages may not be significant. Therefore, whether StarkNet will be able to witness widespread adoption across various sectors remains to be seen. High throughput and low transaction costs are advantageous only for specific use cases. We believe, StarkNet is technology-driven and has a clear positioning for its business model. The team prioritizes providing solutions that truly address user needs than merely chasing flashy new technologies. We are also seeing developers increasingly embracing Cairo and STARK, recognizing their potential as scalable solutions. For example, some projects are developing zkEVM on top of StarkNet, such as Warp and Kakarot, which is a showcase of the strengths of Cairo and StarkNet. Overall, we believe that StarkNet has greater potential in areas such as fully on-chain (FOC) games, contract wallets, cross-chain communication, and on-chain AI because its technical features and innovations bring critical advantages to these fields. , StarkNet’s high-performance and low-cost features make it an ideal choice. By bundling multiple L2 transactions into one transaction on Ethereum, StarkNet can distribute transaction costs among other transactions in the same batch, reducing costs. Furthermore, StarkNet increases network speed, provides high throughput, and minimizes communication requirements. These features will help ensure the efficiency of developing FOC games and a better user experience on FOC games. In the field of FOC games , StarkNet’s native account abstraction allows contract wallets to offer security similar to that of hardware wallets by allowing the encryption chips or modules on a mobile phone to directly sign transactions. Additionally, StarkNet’s highly programmable signature verification enables optimization at the wallet layer for enhanced performance and security through techniques like signature transcriptions. In the sector of contract wallets StarkNet’s decentralized nature and secure design make it a reliable solution for . By utilizing zero-knowledge proofs, StarkNet allows for the performance of verification and proof without revealing transaction details, ensuring data privacy and security. With StarkNet, the trustworthiness and security of cross-chain communication can be improved, thus facilitating more data exchange and interoperation among various chains. cross-chain communication , StarkNet’s technical features allow off-chain computation with on-chain verification of generated proofs. This enables compute-extensive applications such as AI and machine learning models to be put on-chain while enjoying the convenience of not exposing sensitive data and model details. Also, StarkNet’s zero-knowledge proof capabilities can be used to verify the correctness of AI computations, increasing user trust in the results. Overall, it will open new possibilities for on-chain AI use cases in areas such as gaming, oracles, automated trading, anti-sybil, KYC, and more. In the field of on-chain AI In summary, we believe, with continuous technological development and innovation, the StarkNet ecosystem has the potential to maintain its lead in competition. But it will need to stand up to challenges to maintain sustainability and grow the user base. Through continuous innovation and close collaboration with developers and users, StarkNet may continue to evolve and create new use cases for Ethereum.

Is the StarkNet Ecosystem Overvalued?

¿Está sobrevalorado el ecosistema StarkNet?

L'écosystème StarkNet est-il surévalué ?

क्या स्टार्कनेट इकोसिस्टम का मूल्य अधिक है?

StarkNet エコシステムは過大評価されていますか?

O ecossistema StarkNet está supervalorizado?

Hệ sinh thái StarkNet có được định giá quá cao không?

StarkNet 生态系统是否被高估？

Over the past year, we have seen an increase in layer two scaling solutions for Ethereum, with ZK-rollups being some of the most promising. Thanks to the Stark rollup, any decentralized application can achieve a limitless computing scale, which keeps the Ethereum network secure and stable. This is made feasible by the fact that the STARK cryptographic proof system, which is the most flexible and scalable of all cryptographic proof systems, is used by StarkNet. And Infura, Web3’s top node provider, now offers StarkNet compatibility through its node-providing service! By providing StarkNet RPC endpoints, Infura helps bridge the gap for Ethereum developers and facilitates a composable Web3 ecosystem. This article covers what StarkNet is, how it contributes to Ethereum scalability, and how developers can get started by launching a smart contract to the network using Infura. You also learn how to access StarkNet with Infura RPC endpoints and deploy your own ERC-20 tokens on the network. Ethereum Scaling Adding a bridge to a layer two network is one of the most effective strategies to maximize the value of crypto assets. Lower transaction fees, more throughput, and improved customer experience are all benefits of doing this. Rollups are some of the most widely used options for layer two scaling solutions. They function by processing transactions off-chain. They can also guarantee transaction data storage on the Ethereum chain, boosting layer one network security. create cryptographic proofs that demonstrate the legitimacy of a transaction. It's interesting to note that each batch of transactions would have a unique "validity proof" filed on the main chain. , on the other hand, assume that all transactions are valid and can submit batches of transactions without any calculations. Zero-knowledge rollups Optimistic rollups The ZK rollups' ability to assess transaction integrity would rely on cryptographic proofs. Conversely, the time between submitting the rollup and its acceptance on the base chain is difficult for optimistic rollups. StarkNet and STARKs is a permissionless decentralized ZK-rollup. It functions as an L2 network on top of Ethereum, allowing any dapp to reach an infinite scale for processing without affecting Ethereum's security and composability. StarkNet By utilizing , interactive oracle proofs (IOPs), and fast algebraic local coding protocols like FRI, StarkNet's cryptographic hashing functions are the quickest. They outperform all other ZK technology. quasi-linear probabilistically checkable proofs (PCPs) The Solidity to Cairo compiler also enables faster builds for Solidity developers using the ZK rollup, facilitating the use of established Solidity tools in the developer’s stack. StarkNet Endpoints with Infura Infura, a Web3 Infrastructure-as-a-Service (IaaS) provider, offers various services and tools for blockchain developers. The Infura Application Programming Interface (API) suite is part of this. Any project pushing a lot of traffic through the Ethereum network, or one that plans to, can benefit from Infura's modular scaling solutions. The network of hosted Ethereum clients, which supports mainnet and testnets via client-compatible JSON-RPC over HTTPS and WSS, is the most well-known component of the Infura infrastructure. StarkNet endpoints are now widely available and supported by Infura. StarkNet enables indefinite scalability of any commercial use case, backed by STARKs, the most potent zero-knowledge proofs in the Ethereum ecosystem. How To Launch a Project on StarkNet with Infura Prerequisites Before getting started, we need the following prerequisites: and its package manager NPM. Node.js Verify we have Node.js installed by using the following terminal command: node -v && npm -v An Infura account Basic understanding of JavaScript Create an Infura account to access the StarkNet network To access a StarkNet node and execute requests, we will need an Infura endpoint. Visit the Infura website to for a new account or if you already have one. sign up log in After successfully signing up, the page redirects to our dashboard, where we can create a new key, as shown below. Click the "Create a New Key" button and fill in the required information. Next, click the "MANAGE KEY" button, scroll down to the Starknet section, select Goerli network, and copy the URL. Building a project on StarkNet with Infura This section will build our application from scratch to implement account creation, deployment, minting, and transferring tokens. StarkNet Project setup and installation We'll create an empty project and install the library dependency using the following commands. starknet.js mkdir deploy-erc-20-token-with-starknet
cd deploy-erc-20-token-with-starknet
npm init -y
npm install starknet dotenv
touch index.js Next, create a file and paste the StarkNet URL we copied from our Infura dashboard. .env STARKNET_TESTNET_ENDPOINT=https://starknet-goerli.infura.io/v3/<API-KEY> Download the account contract ABI Head to the to download the contract ABI for and . contract folder in this repository ERC-20 OZAccount Create a new folder called . Then, create two new files inside the folder, and . contracts ERC20.json OZAccount.json Next, we will paste the contract ABI we copied into those files. Our project folder structure should look similar to what we have below. Setup provider We may communicate with the StarkNet network through the Provider API without signing any transactions or messages. We will set up a provider via the Infura API endpoint, but in some cases, we may also want to use the default provider. Inside the file, add the following code snippet. index.js import dotenv from "dotenv";
import fs from "fs";
import { Account, Contract, ec, json, stark, Provider, number } from "starknet";
import readline from "readline";

dotenv.config();

// Initialize provider
const url = process.env.STARKNET_TESTNET_ENDPOINT;

console.log("Using Infura Starknet provider: ", url);

const provider = new Provider({
  rpc: {
    nodeUrl: url,
  },
}); In the code snippet above, we Imported the , , and libraries starknet fs dotenv Initialized the provider URL Created a new instance of the from the library Provider starknet Generate private and public key pairs Since StarkNet does not support Externally Owned Accounts (EOA), all accounts on its network are contracts. In contrast to Ethereum, where public and private key pairs facilitate accounts, StarkNet accounts are the only means to sign transactions and communications and confirm signatures. Consequently, a Contract-Account interface is required. Let us generate public and private key pairs with the following code snippet. // Generate public and private key pair.
const privateKey = stark.randomAddress();

const starkKeyPair = ec.genKeyPair(privateKey);
const starkKeyPub = ec.getStarkKey(starkKeyPair);

// Log the Public and Private key pair.
console.log(`Private key: ${privateKey}`);
console.log(`Public key: ${starkKeyPub}`); To test our application in the next step and every step afterward, use the following command: node index We will use the command above each time we need to run the project locally. If you are getting a SyntaxError stating you can’t use the import statement outside of a module, add "type": "module" to your package.json file. Note: We should have something similar to the output below. Write down both keys in case we need to use them again for other procedures in the future. Never share your private keys with anyone, and keep them secure. Deploy a new account on StarkNet By utilizing the provider method and passing the previously produced public key as input, we can deploy the pre-compiled account contract to StarkNet. deployContract Add the following code snippet to deploy the account contract, and we will wait for it to be verified on StarkNet. //...

// Deploy the Account contract and wait for it to be verified on StarkNet.
console.log(
  `////////////////////////////////////////////////////////////////////////////////
    Deployment Tx - Account Contract to StarkNet...
   ////////////////////////////////////////////////////////////////////////////////`
);

const compiledOZAccount = json.parse(
  fs.readFileSync("./contracts/OZAccount.json").toString("ascii")
);

const accountResponse = await provider.deployContract({
  contract: compiledOZAccount,
  constructorCalldata: [starkKeyPub],
  addressSalt: starkKeyPub,
});
console.log("Account address ", accountResponse.contract_address);

console.log(
  `See account on the explorer: https://goerli.voyager.online/contract/${accountResponse.contract_address}`
);

console.log(
  `Follow the tx status on: https://goerli.voyager.online/tx/${accountResponse.transaction_hash}`
);

console.log(
  `////////////////////////////////////////////////////////////////////////////////
    Waiting for Tx to be Accepted on Starknet - OpenZeppelin Account Deployment...
   ////////////////////////////////////////////////////////////////////////////////`
);

await provider.waitForTransaction(accountResponse.transaction_hash);

console.log("Account contract deployed successfully!"); This operation may require a few minutes to complete, but we can always track its progress via the explorer URL logged on the console. To avoid creating multiple accounts each time we run the command to start the project, be sure to fill out the rest of the code in the project. Fund the new account Before anything else, we must add some code to pause the execution and resume it after all of the above actions are completed. Once launched, this pause is necessary because our function won't stop; we’ll need time to fund our account and confirm the transaction. Hence, we will include the following method in the file. index.js //…

function askQuestion(query) {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  return new Promise((resolve) =>
    rl.question(query, (ans) => {
      rl.close();
      resolve(ans);
    })
  );
}

const ans = await askQuestion(
  "Did you add funds to your Account? Hit enter if yes"
); Note: Before running the program again, be sure to fill out the rest of the code in the project. This will avoid having to fund multiple accounts. After running the code again, we should have a prompt similar to what we have below, pausing the execution while adding some faucets to our account. We need to put some gas in our tank before executing transactions on the StarkNet network (just like we can on Ethereum). Using the official , we can fund our account by pasting the account address from the terminal output. StarkNet Goerli Faucet Once the transaction is approved, hit enter to continue with the rest of the code. Deploy ERC-20 contract We have successfully created a provider, generated private and public key pairs for our Contract-Account interface, deployed account contracts, and funded our account in the previous steps. In this section, we will deploy the ERC-20 contract using the following code snippet. //...

// Use your new account address
const account = new Account(
  provider,
  accountResponse.contract_address,
  starkKeyPair
);

console.log("Reading ERC20 Contract...");

const compiledErc20 = json.parse(
  fs.readFileSync("./contracts/ERC20.json").toString("ascii")
);

// Deploy an ERC20 contract and wait for it to be verified on StarkNet.
console.log(
  `////////////////////////////////////////////////////////////////////////////////
     Deployment Tx - ERC20 Contract to StarkNet...
   ////////////////////////////////////////////////////////////////////////////////`
);

const erc20Response = await provider.deployContract({
  contract: compiledErc20,
});

// Wait for the deployment transaction to be accepted on StarkNet
console.log("Waiting for Tx to be Accepted on Starknet - ERC20 Deployment...");

await provider.waitForTransaction(erc20Response.transaction_hash);

// Get the erc20 contract address
const erc20Address = erc20Response.contract_address;

console.log("ERC20 Address: ", erc20Address);

// Create a new erc20 contract object
const erc20 = new Contract(compiledErc20.abi, erc20Address, provider);

erc20.connect(account); Minting tokens Next, we will mint our tokens utilizing the mint transaction, which will take the account address of the recipient and the number of tokens. Let us implement that functionality using the following code snippet. //...

// Mint 500 tokens to account address
console.log(
  `////////////////////////////////////////////////////////////////////////////////
    Invoke Tx - Minting 500 tokens to ${account.address}...
   ////////////////////////////////////////////////////////////////////////////////`
);

const { transaction_hash: mintTxHash } = await erc20.mint(
  account.address,
  "500",
  {
    // transaction can be rejected if maxFee is lower than actual
    // Error: REJECTED: FEE_TRANSFER_FAILURE
    // Actual fee exceeded max fee.
    maxFee: "999999995330000",
  }
);

// Wait for the invoke transaction to be accepted on StarkNet
console.log(`Waiting for Tx to be Accepted on Starknet - Minting...`);

await provider.waitForTransaction(mintTxHash);

// Check balance - should be 500
console.log(`Calling StarkNet for account balance...`);

const balanceBeforeTransfer = await erc20.balance_of(account.address);

console.log(
  `account Address ${account.address} has a balance of:`,
  number.toBN(balanceBeforeTransfer.res, 16).toString()
); Transfer tokens Now that we have minted tokens let’s transfer some to confirm they exist and are transferable. //...

// Execute transfer of ERC20 tokens
console.log(`Invoke Tx - Transfer 20 tokens back to erc20 contract...`);
const { code, transaction_hash: transferTxHash } = await account.execute(
  {
    contractAddress: erc20Address,
    entrypoint: "transfer",
    calldata: [erc20Address, "20"],
  },
  undefined,
  {
    maxFee: "999999995330000",
  }
);

// Wait for the invoke transaction to be accepted on StarkNet
console.log(
  `////////////////////////////////////////////////////////////////////////////////
    Waiting for Tx to be Accepted on Starknet - Transfer...
   ////////////////////////////////////////////////////////////////////////////////`
);

await provider.waitForTransaction(transferTxHash);

// Check balance after transfer - should be 480
console.log(`Calling StarkNet for account balance...`);
const balanceAfterTransfer = await erc20.balance_of(account.address);

console.log(
  `account Address ${account.address} has a balance of:`,
  number.toBN(balanceAfterTransfer.res, 16).toString()
); In the last section of the code, we check the balance of our account. As you can see from the output, our transactions were successful, and we hold a balance of our tokens. Voila! 🥳 We have minted our first ERC-20 tokens on StarkNet with Infura! To follow up, you can find the entire code for this project on a GitHub repository . here Conclusion In this article, you learned about the StarkNet layer two ZK-rollup, how to access it with Infura RPC endpoints, and how to create and deploy your own ERC-20 tokens on the network. Infura helps bridge the gap for Ethereum developers and facilitates a composable Web3 ecosystem by providing these endpoints. To learn more about StarkNet and how to build on it using Infura, visit the following resources: Resources Infura documentation StarkNet documentation StarkNet.js documentation OpenZeppelin Account Cairo contract documentation Also published . here

A Guide to Infura and StarkNet ZK-Rollup for Ethereum Devs

Smart contract oracles protect DeFi protocols from price manipulation attacks: make the protocols safe, and are their most significant dependency simultaneously. Thus, choosing an oracle is a critical decision in the design of a protocol. StarkNet   is a ZK-rollup on the Ethereum chain that solves the “scaling” problem of Ethereum in a highly-efficient manner. The network was released in November 2021, and in a short life of around 10 months, it has given birth to multiple projects from the DeFi space, NFTs, and even gaming (a whole list of projects building on StarkNet can be found ). Though the scaling problem of Ethereum can probably be solved with L2 solutions built on top of the secure layer of the Ethereum mainnet, the problem of permissionlessly getting off-chain data on chain persists. here The two largest oracles building on StarkNet are and the . I had a conversation with Jonas Nelle, the co-founder of Empiric, and Vlad, founder and CEO of Stork, on their view of how these oracles are going to provide accurate data on-chain and the immense possibilities that have now been unlocked with StarkNet’s cheap computation (and a bit expensive storage cost). Empiric Network Stork Oracle Network Currently available data Right now, both Empiric and Stork provide price data for some of the most prominent cryptocurrencies (BTC, ETH, DAI, etc). Along with that, Empiric Network has plans to make data like weather data in a specific place or the outcome of a sports match available. Meanwhile, the Stork team is also interested in equity prices (i.e. stocks), NFTs, and other asset classes. Once these are added, non-price-related feeds might also get added by Stork as well. The wide diversity of information made available by these oracles is very helpful for the ecosystem. Since only price data is available as of this writing, I set out to do an exploratory data analysis on the data sent by these oracles on the Starknet testnet and compare the quality (and quantity) for both. Stork Some basic facts to note are: Stork is an oracle with on-chain price computation. This means that median prices are calculated based on price quotes provided by individual publishers rather than being aggregated off-chain on StarkNet Allowlisted publishers can publish and sign data on-chain Right now 2 publishers are live publishing price updates on the testnet (Dexterity - a financial firm in crypto - and the other is Stork) Has 5 price tickers available (a more updated list can be found ) here The median time between price updates was 180 seconds Now, let’s get to the exciting part - the numbers . I analyzed the price published for BTC and ETH on the Stork contract between July 31, 2022, and August 12, 2022. 🤓 As we can see from the graph above, the price range for BTC in the given timeframe was $2403 (i.e. there are no discrepancies in the range of data). However, in some cases, there are large intervals between updates (up to 4 hours) according to the dataset. The dataset was an offline record of transactions that were sent as transactions to the network. Since this record is not supposed to be saved by Stork (there is no use case for this), the data isn’t supposed to be reliable. Hence, I analyzed the on-chain frequency of transactions on the contract that was shared by Vlad. The on-chain transactions revealed a more optimistic observation. The longest time difference between two updates was 3000 seconds, and these updates probably coincided with the downtimes of the StarkNet network itself. Most of the updates were in the range of 2-3 minutes. A distribution plot of the differences can be found below: The Stork team is actively adding new publishers in the coming weeks as of this writing. I believe that once more publishers are added, the updates will easily become more frequent, and the downtimes will not be that long. Empiric Network The Empiric oracle seems more mature and provides 20+ price feeds, including both spot and options (full list here: ). Their codebase has been open source since day 1, and I was told they had just successfully completed their first audit. Though let us take a closer look at the data. A few facts first: https://docs.empiric.network/using-empiric/supported-assets Allowlisted publishers can publish data on-chain (Empiric Network, CMT, Gemini, FTX, CEX, BitStamp, Coinbase, Kraken, Binance, Bitfinex, Coingecko) Has 17 price tickers available (list ) here The median time between two price updates for the empiric publisher was 93 seconds The median time between two price updates when considering all publishers was less than 5 seconds We got the following results upon analyzing Empiric for the price of BTC between July 31, 2022, and August 12, 2022. The price range for BTC was 2468, and the maximum downtime was for 7 minutes, with most of the updates taking less than one minute (see stats below) It might be surprising that some updates had less than 5 seconds of gap between them. This is probably due to the number of publishers sending the transactions with the updated prices. Empiric’s cofounder, Jonas, mentioned during our interaction that specific mechanisms could be implemented to explicitly favor timing coordination among publishers, and the updates may remain at small intervals. Stork can indeed implement this mechanism in the future once they have a more extensive network of publishers. Since the price updates for Empiric also mentioned the source of the data, I looked at the actual closeness of the data to real-time prices (from the CoinGecko API) at 5-minute intervals. An example of the data retrieved from Empiric is given below for a clearer understanding. The is the actual source of price (market-maker, AMM, etc.) of the asset, while is the entity that sends the transaction on-chain. source the publisher By taking only the updates from set as publisher and as the source, we saw that the price was within -0.002 % of the price returned by CoinGecko API at 5-minute intervals over around 24 hours. I could not run a similar analysis on the Stork data since the data we received from Stork did not have the sources of data segregated and instead had an aggregated price feed. the empiric coingecko It is very important to understand that a larger number of publishers on the Empiric network gives it the upside of having more frequent updates published. The bottleneck, however, is the block frequency of the StarkNet network itself. The data we analyzed above is the history of transactions sent and the corresponding timestamp of the transaction being sent. However, they get added to a block whenever a new block is created and published (which takes around 3 mins today). By taking only the updates from set as publisher and as the source, we saw that the price was within -0.002 % of the price returned by CoinGecko API at 5-minute intervals over around 24 hours. I could not run a similar analysis on the Stork data since the data we received from Stork did not have the sources of data segregated and instead had an aggregated price feed. the empiric coingecko It is very important to understand that a larger number of publishers on the Empiric network gives it the upside of having more frequent updates published. The bottleneck, however, is the block frequency of the StarkNet network itself. The data we analyzed above is the history of transactions sent and the corresponding timestamp of the transaction being sent. However, they get added to a block whenever a new block is created and published (which takes around 3 mins today). How “permissionless” are current oracles? As mentioned in this post, Stork and Empiric only enable allowlisted publishers (mostly high-volume market makers and exchanges) to publish the latest price to the respective smart contracts. I am sure both teams are working on a truly permissionless way of proving the price of an asset. However, right now, the centralized nature of the data being published is to be expected from projects at a nascent stage. Empiric recently the in collaboration with Coinbase and OKX. This allows any user to publish the price data received from their APIs with the exchanges’ signatures. As a result, even though the data source remains permissioned (and multiple publishers might use the same source), these are positive steps toward a completely decentralized oracle system. ported open oracle standard The most prominent example available today is Chainlink. Anyone is allowed to stake some assets, spin up a node, and start sharing their knowledge about the off-chain (IRL) world. However, only certain entities can publish data to the official Chainlink price feeds ( ) - which are used mainly by Defi protocols in the space. The approach that Chainlink has developed makes sense because entities with large market caps have a reputation to uphold and minimal upside to gain from (if any) by publishing dishonest data on the chain. On the other side, since anyone can spin up a node, it is the responsibility of the node maintainer to increase their outreach and build a historical reputation for being a high-quality data provider. here Moreover, since both Empiric and Stork oracles are decentralized in the way that the originator of the price update transaction always is the publisher (who has the private key to their public wallet), any malicious attempts to skew the price reflected by the oracle will only result in reputation loss. Any oracles on StarkNet can implement simple aggregation modes like the median of most recent updates to prevent a single source from skewing the data. Both Stork and Empiric employ these and similar techniques. Will the updates remain as frequent when moving to mainnet? It is a big “if“ to assume that the updates remain just as frequent once these oracles move to the mainnet. On StarkNet, the computation cost is infinitesimal, yet the storage cost is relatively high. Hence any updates to the storage of the network may cost higher than expected once moved to the mainnet. However, another interesting fact is that overwriting the same storage slot multiple times in a single block will not result in high storage costs. Hence you only pay storage fees while updating the value - if it stays the same, you pay nothing. The cost would still be of a single write since the final value of the slot is sent to Ethereum Mainnet as calldata. Due to these reasons, StarkNet may issue batching rebates in the future for multiple overwrites of the same storage slot. Computational feeds and other possibilities for future research As the computational effort required to verify STARK proofs is compared to the computation proven, StarkNet has the potential to scale Ethereum by orders of magnitude; this gives rise to new possibilities like running live computational feeds that can aggregate data provided by oracles, calculating yield curves, and possibly even modeling them on-chain. o, a fixed rate loan protocol, is already working on an integration with Empiric's data feeds to price their fixed rate loans on StarkNet. Right now, CurveZero is live on testnet, and you can take out a test fixed yield loan on their . Similarly. Projects like can use a wide source of information from oracles on Starknet and aggregate the feeds to make decisions for depositing their users' liquidity at the highest yields possible. Yagi is integrating with Empiric and will be utilizing their volatility feeds. exponentially small CurveZer website Yagi Finance Yet another approach for further improvement is the possibility of moving to . Since L3s build on top of L2s, similar to how L2s build on top of L1s, publishing data will become even cheaper and more accessible, and multiple transactions will be provably posted on the L2 (unless there is a verifier contract on it). Depending on the use case, data availability may be tuned, and the recursive proofs may be employed to power the progress of this ecosystem. L3s Resources The link to Colab notebooks containing all the results of DA mentioned in the blog post can be found below: Stork evaluation: https://colab.research.google.com/drive/1-K1t4BCAXdVdliI3Dby2jyT84ulLdX44?usp=sharing Empiric evaluation: https://colab.research.google.com/drive/1Bkct5khBkWAp-BvOZnu6VFDvMtRI1Tqz?usp=sharing Empiric Evaluation against CoinGecko: https://colab.research.google.com/drive/17-ilkX0mgWwo9tHUCVmSypb6DrWILmnp?usp=sharing

Oracles on StarkNet

Bringing Web3 ideas to life: Building Grants Programs that Drive Innovation and Change the World

Web3-Ideen zum Leben erwecken: Förderprogramme aufbauen, die Innovationen vorantreiben und die Welt verändern

Ζωντανεύοντας τις ιδέες Web3: Δημιουργία προγραμμάτων επιχορηγήσεων που οδηγούν την καινοτομία και αλλάζουν τον κόσμο

Cómo hacer realidad las ideas de la Web3: creación de programas de subvenciones que impulsen la innovación y cambien el mundo

Mewujudkan ide Web3: Membangun Program Hibah yang Mendorong Inovasi dan Mengubah Dunia

הבאת רעיונות Web3 לחיים: בניית תוכניות מענקים שמניעות חדשנות ומשנות את העולם

Web3のアイデアを実現する: イノベーションを推進し世界を変える助成金プログラムの構築

ເອົາແນວຄວາມຄິດຂອງ Web3 ມາສູ່ຊີວິດ: ການສ້າງໂຄງການຊ່ວຍເຫຼືອລ້າທີ່ຂັບເຄື່ອນການປະດິດສ້າງແລະການປ່ຽນແປງໂລກ

Mampiaina ny hevitra Web3: Fanomanana Fandaharana Fanomezana izay mitondra fanavaozana sy fanovana izao tontolo izao

Menghidupkan idea Web3: Membina Program Geran yang Memacu Inovasi dan Mengubah Dunia

Web3 yuyaykunata kawsayman apamuy: Musuqyachiyta purichiq chaymanta pacha tikrayta purichiq yanapakuy programakuna ruway

Ge Web3-idéer liv: Bygga bidragsprogram som driver innovation och förändrar världen

Ku tisa miehleketo ya Web3 evuton’wini: Ku aka Minongonoko ya Tigranti leyi Fambisaka Vumaki na ku Cinca Misava

Written by: James Strudwick, Executive Director, Starknet Foundation “To understand the world, you must understand Cairo.” This sentiment, often attributed to the Egyptian writer Naguib Mahfouz, speaks to the significant role the ancient city played in shaping global culture, politics, and history. Now, a coding language of the same name is becoming just as essential to understanding the Web3 ecosystem. Like the city itself - a learning gateway to complex histories, Cairo, the coding language, is opening new doors in the decentralised world, driving innovation and accessibility. But what makes Cairo unique compared to other programming tools? And why should Web3 developers invest time to master it? If you are willing to take the plunge and learn the best from the very best, sign up to Starknet’s Bootcamp and learn everything you need to know about Cairo. What Does Cairo Do? Cairo is designed to be a highly optimized provable programming language, and it just so happens that STARKs are great for scaling Ethereum, too, because verifying a proof takes less time than executing the program with the same inputs. Hence, Starknet is quite literally written in Cairo with the goal of scaling Ethereum and building Web3 applications. Starknet enhances Ethereum’s scalability by enabling the network to handle a higher volume of transactions without the usual slowdown or high fees. It achieves this by posting only state differences to Ethereum and aggregating many Starknet state transition proofs together to create a single proof, meaning the proving cost is amortized across many users. This process relies on zero-knowledge proofs (ZKPs), allowing Ethereum to verify transactions securely without exposing each detail—similar to receiving a summary receipt. By processing transactions in bulk and only sharing essential data with Ethereum, Starknet’s use of Cairo not only cuts costs but also improves transaction speed. Use Cases for Cairo Cairo’s efficiency and privacy features make it indispensable for several Web3 applications. In DeFi, Cairo enables platforms to manage high transaction volumes at a lower cost, making services more accessible. In the NFT space, Cairo supports the creation and transfer of digital collectibles with reduced transaction fees, enhancing market accessibility and scalability. Additionally, with Cairo a developer can efficiently verify other proving systems that already have privacy as a common feature. While Cairo’s powerful capabilities make it essential for advancing Ethereum and Web3, its complexity presents a learning curve for developers. However, for those who master it, Cairo unlocks vast potential to drive the future of decentralised applications. As a highly sought after niche skill,  Cairo is valued by like-minded individuals who share a desire to create long lasting applications that can drive mass adoption forward in a meaningful way. They also gain insight into Cairo’s distinct advantages when compared to more popular and traditional programming languages. Cairo vs. Other Programming Languages Take, for example, Rust. With its performance, safety, and multi-platform capabilities, Rust is ideal for developers who want flexibility across blockchain platforms and other applications. However, Cairo is better suited than Rust for Ethereum scaling and specific blockchain applications because it was designed with these use cases in mind. Rust lacks Cairo’s specific capabilities for Ethereum scalability and privacy, like transaction bundling and ZKPs. Cairo’s integration with Starknet and Ethereum makes it a more specialized tool for developers focused on scaling and optimizing Ethereum-based applications. Rust is more versatile and flexible across various blockchain platforms, but it lacks the huge efficiency that Cairo delivers, which scales Ethereum. Cairo vs. Solidity As Ethereum’s primary language for creating smart contracts, Solidity is designed to handle individual transactions within the blockchain. Cairo complements Solidity by addressing Ethereum’s need for scalability, by being an efficient language to verify proofs of computational integrity. Cairo, being both a Smart Contract and programming language, means that it can be used for on-chain and off-chain operations. In comparison, Solidity cannot aggregate blocks together as it can’t be used outside the EVM. By focusing on transaction scalability, Cairo enhances the performance of Solidity-based smart contracts, making the two languages complementary, with Cairo providing a crucial layer for handling high-volume blockchain activity with native computational integrity. Cairo vs. Python While Python is known for its versatility and ease of use across data science, machine learning, and web development, Cairo is a specialised provable language focused on scaling Ethereum. Python’s beginner-friendly design, readability, and flexibility make it ideal for general-purpose applications, but these strengths don’t translate to blockchain-specific needs. While Python is suited to various industries, Cairo’s performance is tailored to the demands of Web3, making it better equipped for blockchain scalability and transaction efficiency. Cairo vs. C++/Java C++ and Java are high-performance, general-purpose languages used in applications such as gaming and enterprise software, where speed and complex logic are required. However, Cairo, with its provable nature and modern compiler architecture, can, in the context of a sequencer, execute operations concurrently and is able to scale to thousands by aggregating execution proofs together, constraining them all against the same set of rules that Ethereum verifies. This gives Cairo great security, as someone can’t produce a block without it complying with the StarknetOS rules. Cairo is also uniquely tailored for the Ethereum blockchain, specifically designed to handle the demands of decentralised finance and high transaction throughput. While C++ and Java excel in traditional, centralised environments. Cairo’s ability to be a developer-friendly provable language, manage bulk transactions off-chain, and verify them securely makes it a superior choice for blockchain scaling, where general-purpose languages like C++ and Java fall short. The other aspect of C++ and Java is that they are antiquated with large user bases, and they want to keep the language mostly the same. This is where Cairo comes in as something different with the ability to adopt new ideas and technologies, further demonstrating its superiority. Why Cairo Matters for Web3 Developers Cairo is a top tier language when it is the right tool for the job, specifically if you want to scale Ethereum, but if you want super efficient (non-verifiable) memory safe programs then Rust should be your go-to. However, as demand for Ethereum applications grows, so does the need for solutions that reduce costs and improve speed—making Cairo a key player in the Web3 ecosystem. Developers can overcome the limitations of traditional coding languages in blockchain and bring applications to life that operate at scale and at lower costs. While it may not yet be as widespread as other languages Cairo is crucial for the future of Web3. Just as Cairo, the city, is a bridge to understanding complex histories, Cairo, the coding language, is a bridge to a more accessible, efficient, and decentralised future. Does it take time to master? Yes. Can you do it? We want you to. But anything worth doing, anything that will set you apart from the mundane and make you great - requires dedication and effort. Cairo was not built in a day. Web3 won’t be either. However, with a skilled team of developers, the future holds tremendous potential for a better society for everyone. If you are willing to take the plunge and learn the best from the very best, sign up to Starknet’s Bootcamp and learn everything you need to know about Cairo. Written by: James Strudwick, Executive Director, Starknet Foundation Written by: James Strudwick, Executive Director, Starknet Foundation Written by: James Strudwick, Executive Director, Starknet Foundation Starknet Foundation Starknet Foundation “To understand the world, you must understand Cairo.” “To understand the world, you must understand Cairo.” “To understand the world, you must understand Cairo.” This sentiment, often attributed to the Egyptian writer Naguib Mahfouz, speaks to the significant role the ancient city played in shaping global culture, politics, and history. Now, a coding language of the same name is becoming just as essential to understanding the Web3 ecosystem. Like the city itself - a learning gateway to complex histories, Cairo, the coding language, is opening new doors in the decentralised world, driving innovation and accessibility. But what makes Cairo unique compared to other programming tools? And why should Web3 developers invest time to master it? If you are willing to take the plunge and learn the best from the very best, sign up to Starknet’s Bootcamp and learn everything you need to know about Cairo. If you are willing to take the plunge and learn the best from the very best, sign up to Starknet’s Bootcamp and learn everything you need to know about Cairo . Starknet’s Bootcamp and learn everything you need to know about Cairo Starknet’s Bootcamp and learn everything you need to know about Cairo What Does Cairo Do? Cairo is designed to be a highly optimized provable programming language, and it just so happens that STARKs are great for scaling Ethereum, too, because verifying a proof takes less time than executing the program with the same inputs. Hence, Starknet is quite literally written in Cairo with the goal of scaling Ethereum and building Web3 applications. Starknet enhances Ethereum’s scalability by enabling the network to handle a higher volume of transactions without the usual slowdown or high fees. It achieves this by posting only state differences to Ethereum and aggregating many Starknet state transition proofs together to create a single proof, meaning the proving cost is amortized across many users. This process relies on zero-knowledge proofs (ZKPs), allowing Ethereum to verify transactions securely without exposing each detail—similar to receiving a summary receipt. By processing transactions in bulk and only sharing essential data with Ethereum, Starknet’s use of Cairo not only cuts costs but also improves transaction speed. Use Cases for Cairo Cairo’s efficiency and privacy features make it indispensable for several Web3 applications. In DeFi, Cairo enables platforms to manage high transaction volumes at a lower cost, making services more accessible. In the NFT space, Cairo supports the creation and transfer of digital collectibles with reduced transaction fees, enhancing market accessibility and scalability. Additionally, with Cairo a developer can efficiently verify other proving systems that already have privacy as a common feature. While Cairo’s powerful capabilities make it essential for advancing Ethereum and Web3, its complexity presents a learning curve for developers. However, for those who master it, Cairo unlocks vast potential to drive the future of decentralised applications. As a highly sought after niche skill,  Cairo is valued by like-minded individuals who share a desire to create long lasting applications that can drive mass adoption forward in a meaningful way. They also gain insight into Cairo’s distinct advantages when compared to more popular and traditional programming languages. Cairo vs. Other Programming Languages Take, for example, Rust. With its performance, safety, and multi-platform capabilities, Rust is ideal for developers who want flexibility across blockchain platforms and other applications. However, Cairo is better suited than Rust for Ethereum scaling and specific blockchain applications because it was designed with these use cases in mind. Rust lacks Cairo’s specific capabilities for Ethereum scalability and privacy, like transaction bundling and ZKPs. Cairo’s integration with Starknet and Ethereum makes it a more specialized tool for developers focused on scaling and optimizing Ethereum-based applications. Rust is more versatile and flexible across various blockchain platforms, but it lacks the huge efficiency that Cairo delivers, which scales Ethereum. Cairo vs. Solidity As Ethereum’s primary language for creating smart contracts, Solidity is designed to handle individual transactions within the blockchain. Cairo complements Solidity by addressing Ethereum’s need for scalability, by being an efficient language to verify proofs of computational integrity. Cairo, being both a Smart Contract and programming language, means that it can be used for on-chain and off-chain operations. In comparison, Solidity cannot aggregate blocks together as it can’t be used outside the EVM. By focusing on transaction scalability, Cairo enhances the performance of Solidity-based smart contracts, making the two languages complementary, with Cairo providing a crucial layer for handling high-volume blockchain activity with native computational integrity. Cairo vs. Python While Python is known for its versatility and ease of use across data science, machine learning, and web development, Cairo is a specialised provable language focused on scaling Ethereum. Python’s beginner-friendly design, readability, and flexibility make it ideal for general-purpose applications, but these strengths don’t translate to blockchain-specific needs. While Python is suited to various industries, Cairo’s performance is tailored to the demands of Web3, making it better equipped for blockchain scalability and transaction efficiency. Cairo vs. C++/Java C++ and Java are high-performance, general-purpose languages used in applications such as gaming and enterprise software, where speed and complex logic are required. However, Cairo, with its provable nature and modern compiler architecture, can, in the context of a sequencer, execute operations concurrently and is able to scale to thousands by aggregating execution proofs together, constraining them all against the same set of rules that Ethereum verifies. This gives Cairo great security, as someone can’t produce a block without it complying with the StarknetOS rules. Cairo is also uniquely tailored for the Ethereum blockchain, specifically designed to handle the demands of decentralised finance and high transaction throughput. While C++ and Java excel in traditional, centralised environments. Cairo’s ability to be a developer-friendly provable language, manage bulk transactions off-chain, and verify them securely makes it a superior choice for blockchain scaling, where general-purpose languages like C++ and Java fall short. The other aspect of C++ and Java is that they are antiquated with large user bases, and they want to keep the language mostly the same. This is where Cairo comes in as something different with the ability to adopt new ideas and technologies, further demonstrating its superiority. Why Cairo Matters for Web3 Developers Cairo is a top tier language when it is the right tool for the job, specifically if you want to scale Ethereum, but if you want super efficient (non-verifiable) memory safe programs then Rust should be your go-to. However, as demand for Ethereum applications grows, so does the need for solutions that reduce costs and improve speed—making Cairo a key player in the Web3 ecosystem. Developers can overcome the limitations of traditional coding languages in blockchain and bring applications to life that operate at scale and at lower costs. While it may not yet be as widespread as other languages Cairo is crucial for the future of Web3. Just as Cairo, the city, is a bridge to understanding complex histories, Cairo, the coding language, is a bridge to a more accessible, efficient, and decentralised future. Does it take time to master? Yes. Can you do it? We want you to. But anything worth doing, anything that will set you apart from the mundane and make you great - requires dedication and effort. Cairo was not built in a day. Web3 won’t be either. However, with a skilled team of developers, the future holds tremendous potential for a better society for everyone. If you are willing to take the plunge and learn the best from the very best, sign up to Starknet’s Bootcamp and learn everything you need to know about Cairo. If you are willing to take the plunge and learn the best from the very best, sign up to Starknet’s Bootcamp and learn everything you need to know about Cairo . Starknet’s Bootcamp and learn everything you need to know about Cairo Starknet’s Bootcamp and learn everything you need to know about Cairo

Building dApps that Last: Why Cairo is the Winner Programming Language for Web3 Devs

የሚዘልቅ dApps መገንባት፡ ለምን ካይሮ ለዌብ3 ዴቭስ አሸናፊ ፕሮግራሚንግ ቋንቋ ሆነች።

Izgradnja dApps koje traju: Zašto je Cairo pobjednički programski jezik za Web3 Devs

Cómo crear aplicaciones descentralizadas que duren: por qué Cairo es el lenguaje de programación ganador para los desarrolladores de Web3

Irauten duten dApps eraikitzea: zergatik da Cairo Web3 Devs-en programazio-lengoaia irabazlea

Izrada dApps koje traju: Zašto je Cairo pobjednički programski jezik za Web3 Devs

永続的な dApp の構築: Cairo が Web3 開発者にとって勝者のプログラミング言語である理由

ការកសាង dApps ដែលចុងក្រោយ៖ ហេតុអ្វីបានជា Cairo គឺជាភាសាសរសេរកម្មវិធីអ្នកឈ្នះសម្រាប់ Web3 Devs

ການສ້າງ dApps ສຸດທ້າຍ: ເປັນຫຍັງ Cairo ເປັນພາສາການຂຽນໂປລແກລມຜູ້ຊະນະສໍາລັບ Web3 Devs

Ilgstošas dApps izveide: kāpēc Kaira ir Web3 izstrādātāju programmēšanas valoda

Tworzenie trwałych aplikacji zdecentralizowanych: dlaczego Cairo jest zwycięskim językiem programowania dla programistów Web3

Iň soňky dApps gurmak: Näme üçin Kair Web3 enjamlary üçin ýeňiji programma dili

Ku aka ti dApps leti tshamaka nkarhi wo leha: Ha yini Cairo yi ri Ririmi ra Minongonoko ra Muhluri eka Web3 Devs

How to Build a Sustainable Web3 Ecosystem

Kunjamas mä Ecosistema Web3 Sostenible luraña

Cómo construir un ecosistema Web3 sostenible

Comment construire un écosystème Web3 durable

Como construír un ecosistema Web3 sostible

Kako izgraditi održivi Web3 ekosustav

持続可能なWeb3エコシステムを構築する方法

지속 가능한 Web3 생태계를 구축하는 방법

Cara Membina Ekosistem Web3 yang Mampan

තිරසාර Web3 පරිසර පද්ධතියක් ගොඩනගන්නේ කෙසේද?

Maitiro Ekuvaka Yakasimba Web3 Ecosystem

Làm thế nào để xây dựng một hệ sinh thái Web3 bền vững

如何构建可持续的 Web3 生态系统

Stories, News & Mentions about STARKNET

Starknet’s Stories on HackerNoon