Provable logo

Explore AleoNetwork

Ctrl + K
Coinbase Target
124.73T
Program Calls Last 7 Days
176.2K
Total Network Stake
1.33BALEO
Percent staked
75.0%
Proof Target
31.18T
Deployed Programs
285
Total Transactions
22M
Total Validators
31
Total Provers
163
Total Puzzle Reward
109.86MALEO

Ecosystem News

Introducing the Leo native testing framework

Introducing the Leo native testing framework

With the latest update to the Leo programming language, Aleo developers can now write unit tests directly in Leo code. This new feature enables developers to verify the correctness of their program logic before deploying it to the testnet, allowing for greater confidence in the quality and security of their dApps. Unit testing ensures that your program logic behaves as intended by allowing you to test individual transition functions. This granular level inspection checks that each transition function performs correctly in isolation, thereby helping to identify edge cases and potential vulnerabilities before they can be exploited. Unit tests also facilitate auditing, providing a clear and reproducible method for reviewing code behavior and ensuring compliance with project requirements or regulatory standards. Additionally, by catching bugs early in development, unit tests save you from the headache of redeploying a program to the testnet or mainnet after discovering an issue in production. By incorporating native unit testing into your workflow, your Aleo programs become more reliable, secure, and maintainable. Getting Started First, make sure you are using the latest version of the Leo CLI. The command will automatically generate a test directory containing a file with template code containing a script and a compiled test. leo new <project_name> Wondering why there are two types of tests? That’s because the Aleo blockchain contains both public and private state.  Public state is modified through on-chain execution.  Async transition functions that access mappings can only be tested using scripts.  All other logic, such as minting records or hashing data, can be tested using compiled tests. Importing your main program The test file is a Leo program, so in order to be able to test your main program’s functions, you will first need to import it into your test program. Think of your main program as an external dependency for your test program. All of the transitions that you’ll be testing from your main program will be called as external programs inside of your test function code blocks. Just two more things to keep in mind. First thing to note – every test function must be annotated with the `@test` keyword before the function definition. Second point – test functions do NOT take inputs.  All inputs must be hardcoded inside of the test function code block. Running compiled tests Compiled tests can be used to test any regular transition or helper function. The test will contain an external transition or external inline function, followed by an assert, as follows: @test transition test_simple_addition() { let result: u32 = example_program.aleo/simple_addition(2u32, 3u32); assert_eq(result, 5u32); } You can also test that invalid results are caught by adding a `@should_fail` annotation. @test @should_fail transition test_simple_addition_fail() { let result: u32 = example_program.aleo/simple_addition(2u32, 3u32); assert_eq(result, 3u32); } You can also use compiled tests to make sure that structs and records contain correct values for their respective fields.  @test transition test_record_maker() { let r: example_program.aleo/Example = example_program.aleo/mint_record(0field); assert_eq(r.x, 0field); } Running scripted tests Now for the fun part! Scripts are useful for checking async transitions that interact with mappings.  Since mapping data lives on-chain and since the testing framework can’t fetch on-chain data, we need to populate a mapping with some data before we can test it. Let’s say our main program has an async transition and corresponding async function that updates a mapping called "map": async transition set_mapping(x: field) -> Future { let future_1: Future = finalize_set_mapping(x); return future_1; } async function finalize_set_mapping(x: field) { Mapping::set(map, 0field, x); } How would we write a test to check that the mapping is being updated correctly?  First, we need to replace the `transition` keyword with `script` to indicate that we’re running a script.  Next, within the test code block, we’ll populate the mapping with a hard coded value.  Since `set_mapping` is an async transition that returns a Future, we need to await the Future before checking that the value in the mapping matches the correct value: @test script test_async() { const VAL: field = 12field; let fut: Future = example_program.aleo/set_mapping(VAL); fut.await(); assert_eq(Mapping::get(example_program.aleo/map, 0field), VAL); } How do I run the tests? After you are confident that you have written all the tests required to satisfy unit testing gods, it’s time to give it a spin! If you want to run all of the tests together, simply run the following from the root of your project directory. leo test If you only want to run select tests, you can either supply the test function name or a string that is contained within the name of the test function: leo test test_async Or leo test async Conclusion With Leo's native testing framework, developers can now build more robust and secure Aleo applications by catching bugs early and ensuring their transition functions work correctly before deployment. Get started today by exploring the example repository and diving deeper into the comprehensive Leo language documentation to master unit testing for your dApps.

Announcing snarkOS v3.8.x

Announcing snarkOS v3.8.x

The Provable team is happy to announce a new version of the snarkOS Aleo implementation. Aleo is a cryptocurrency enabling developers to build cryptographically secure dApps. You can already use this version on testnet and it is planned to land on mainnet by June 17th, 2025 - at which point you can also download the release from github. Or, if you’re keen to dive in, build from source anytime you want. Please report any issues you might come across! What's new in v3.8.x snarkVM Consensus change A consensus change solidifying consensus logic will occur at the following block height: Canary - Block 6_895_000 (~June 6th, 2025 at the current block times) Testnet - Block 8_365_000 (~June 15th, 2025 at the current block times) Mainnet - Block 8,392,501 (~June 18th, 2025 at the current block times) ATTENTION: Validators that do not upgrade in time will be at risk of forking and require manual intervention. Clients that do not upgrade will be at risk of halting until an upgrade occurs. New bootstrap peer IPs This PR introduced new bootstrap peer IPs, which are nodes run by the Aleo Network Foundation! They are an optional gateway into the Aleo network. Improvements for developers When you issue cargo run or even cargo test with no code changes at all, cargo would still re-build the snarkOS binary (and this can take a long time) on every single invocation. With a single clean “cargo:rerun-if-changed=” line removed, you will no longer have a rebuild on every run. A bug was present in the previously added unconfirmed transaction endpoint, causing it to return confirmed transactions. This has now been fixed, the endpoint now returns unconfirmed transactions. There were a few things that made the CLI a little awkward to use, which is now improved. The power of Rust shines through scary idiomatic code such as the following: #[clap(default_value_t=MainnetV0::ID, long = "network", value_parser = clap::value_parser!(u16).range((MainnetV0::ID as i64)..=(CanaryV0::ID as i64)))] Improvements for validators A number of stabilization improvements are coming to consensus and peering. For example, the heartbeat logic has no notion of pending connections, so it might call Router::connect multiple times for the same peer while the handshake is happening. This change prevents frequent warnings being generated when a node attempts to connect to a peer, that it already connected or is currently connecting to, by not considering those cases an error. This PR clears the partially_verified_transactions on all the ConsensusVersion changes. All ConsensusVersions change consensus rules and regardless if it is transaction related or not, we clear the partially_verified_transactions out of abundance of caution. Leo 2.7.0: now with type inference! Alongside the new snarkOS release, there will also be a new Leo release. 🦁Leo is a programming language for formally verified, zero-knowledge applications on the Aleo network. From now on, we’ll be using these release notes to give an overview of new exciting features which landed in the programming language. Unsuffixed Literals and Basic Type Inference In many cases it’s now possible to avoid explicitly writing types, or to avoid the type suffix of numeric literals. let x: u8 = 12;       // We no longer have to write `12u8`. let y = 12u8;         // Or, instead of `let y: u8 = ...`, we omit the type. for i in 10u8..16u8 { // Can also omit the type here, instead of `for i: u8`.     // ... } Clearer Reporting for execute and deploy Now when you use deploy and execute, you’ll get better messaging, including checking the status of your transaction. Closing notes The full changelogs for the referenced releases can be found here: https://github.com/ProvableHQ/snarkVM/compare/v3.7.1...testnet-v3.8.0 https://github.com/ProvableHQ/snarkOS/compare/v3.7.1…testnet-v3.8.0 https://github.com/ProvableHQ/leo/compare/v2.6.0...testnet-v2.7.0 Contributors A big thank you to all the contributors to this snarkVM, snarkOS and Leo release! @cypherpepe @d0cd @ljedrz @kaimast @kpandl @ljedrz @mikebenfield @​​mohammadfawaz @niklaslong @raychu86 @vicsn @VolodymyrBg

ProvaHack 2.0: Building Privacy dApps on Aleo

ProvaHack 2.0: Building Privacy dApps on Aleo

Earlier this month (May 2–15, 2025), Provable hosted ProvaHack 2.0, a two-week internal codefest where our team built open-source, privacy-preserving dApps on Aleo. Participants used Leo programs and deployed projects to the Aleo mainnet. What We Built on Aleo Each team leaned into Aleo’s strengths—proofs that keep data private, seamless on-chain deployments, and the flexibility of Leo. Here’s a deeper dive: Verifaleo Description: Verifaleo addresses the need for privacy-preserving identity verification (KYC) in dApps. It uses Aleo to link verified identities to soulbound NFTs, allowing users to prove their KYC status to services without repeatedly exposing sensitive personal data. Aleo's ZK proofs ensure that dApps can trust the verification status tied to an NFT without accessing the underlying private information, facilitating compliance while upholding user privacy. Codebase: https://github.com/esren0x/kycNFT PriceProof Description: PriceProof creates decentralized price prediction markets on Aleo, focusing on security and user privacy. The core problem it solves is enabling users to stake on future price movements anonymously, with Aleo's ZK proofs validating that reported outcomes verifiably match on-chain oracle data. This ensures a trustless and transparent market where participants are protected, and their strategies remain private. Codebase: https://github.com/bendyarm/priceproof/tree/main/leo/price_proof_test_1 The Solo Gambit (Pawnstorm) Description: Pawnstorm, from The Solo Gambit, introduces a chess variant with a twist: hidden bombs! The core challenge solved on Aleo is managing this hidden information and validating moves without a trusted third party. Aleo's ZK proofs allow each player's secret bomb placements to be tracked privately on-chain, ensuring fair play and strategic depth as moves are validated against both public game rules and private, hidden states. Codebase: https://github.com/mikebenfield/pawnstorm Proof of Bitcoin Description: Proof of Bitcoin tackles the challenge of privately proving ownership of Bitcoin reserves. Using Aleo, this project allows users to generate ZK proofs demonstrating they hold a certain amount of BTC without revealing their Bitcoin addresses or transaction histories. This is achieved by implementing critical cryptographic components on Aleo, such as ECDSA signature verification for Bitcoin's secp256k1 curve and necessary hash functions, enabling publicly verifiable yet private attestations of off-chain assets. Codebase: https://github.com/vicsn/snarkvm-btc-balance-verification/tree/ecdsa RetroBeatz Description: RetroBeatz offers a nostalgic quiz on classic game soundtracks, aiming to boost Aleo engagement through a fun, community-oriented dApp. The challenge lies in creating an interactive experience on Aleo that can manage quiz mechanics and potentially track high scores in a decentralized manner. It demonstrates Aleo's versatility for building user-friendly applications that can foster community and showcase the platform's accessibility. Codebase: https://github.com/wei-provable/midi-player Daddy’s Orders Description: Daddy’s Orders tackles decision fatigue with a fun, privacy-preserving randomizer on Aleo. The core challenge is generating a verifiably random Taco Bell order (main, side, drink) without a trusted central party. Aleo's ZK proofs ensure the randomness is generated on-chain and the outcome is truly unpredictable, offering a private and amusing way to let fate decide your meal. Codebase: https://github.com/christianwwwwwwww/daddys-orders snorkle Description: Snorkle provides a privacy-preserving oracle, tackling the challenge of securely bringing real-world data on-chain. Using secure enclaves and Aleo's zero-knowledge proofs, this service fetches external data feeds and attests to their authenticity without exposing sensitive API keys or endpoints. This allows dApps to trust and use external information privately and securely. Codebase: https://github.com/d0cd/snorkle lodive Description: Lodive addresses privacy and security in event ticketing by building a platform on Aleo. The core problem it solves is enabling the sale of soulbound tickets where attendee data is encrypted, ensuring buyer anonymity and preventing common issues like scalping and secondhand market scams. Aleo's ZK proofs allow event organizers to verify ticket authenticity and admission without accessing attendees' personal information, enhancing privacy throughout the ticketing lifecycle. Codebase: https://github.com/alexpitsikoulis/lodive Knightfall Description: Knightfall introduces Fog-of-War Chess to the Aleo blockchain, tackling the challenge of hidden information in strategy games. Aleo's zero-knowledge proofs conceal players' pieces from their opponent until they enter attack range, creating tactical suspense. This approach ensures fair play and privacy by managing hidden game states on-chain without revealing them prematurely. Codebase: https://github.com/dgrkotsonis/knightfall-aleo https://github.com/emmaprice082/knightfall Feeling inspired? Explore the Awesome Aleo GitHub repo! This is your go-to hub for Aleo developers and ZK enthusiasts. It gathers tutorials (from beginner to advanced), project ideas, and useful tools to jumpstart your work with Aleo’s privacy-focused platform. Whether you’re building dApps, exploring zero-knowledge proofs, or contributing to the Aleo ecosystem, it’s the perfect launchpad. Take the next step and immerse yourself in the Aleo ecosystem. By joining this ecosystem, you'll connect with like-minded individuals, gain access to exclusive resources, and have the opportunity to contribute to groundbreaking projects. Whether you're a seasoned developer, a curious newcomer, or simply passionate about ZK, the Aleo ecosystem welcomes your participation in building a more secure digital future.

Announcing snarkOS v3.7.x

Announcing snarkOS v3.7.x

The Provable team is happy to announce a new version of the snarkOS Aleo implementation. Aleo is a cryptocurrency enabling developers to build cryptographically secure dApps. You can already use this version on testnet and it is planned to land on mainnet by May 20th, 2025 - at which point you can also download the release from github. Or, if you’re keen to dive in, build from source anytime you want. Please report any issues you might come across! What's new in v3.7.x snarkVM Consensus changes: increase to 35 validators A consensus update is going to take place, allowing the validator count to increase to 35! Extensive load-testing was performed to confirm the robustness of the larger network. In future releases, the validator set will continue to increase in a responsible manner. Excitingly, due to the use of the Bullshark-based AleoBFT consensus algorithm, this increased validator set will increase the throughput of Aleo! The consensus changes will occur at the following block heights: Canary - Block 6_240_000 (~May 2nd, 2025 at the current block times) Testnet - Block 7_600_000 (~May 18th, 2025 at the current block times) Mainnet - Block 7_557_000 (~May 21st, 2025 at the current block times) ATTENTION: Validators that do not upgrade in time will be at risk of forking and require manual intervention. Clients that do not upgrade will be at risk of halting until an upgrade occurs. Improvements for developers Many developers and auditors are working hard to add program upgradability to Aleo. While this feature itself is not yet merged yet, several components which lead up to it, such as a cleanup of how imports are managed in snarkVM. This change, combined with program upgradability, will allow for cycles in the import graph, further increasing the expressivity of Aleo programs. We also got help from the wider ecosystem to harden the codebase. When deserializing an Authorization from a string that included multiple transitions, the structural assertion logic would erroneously fail - and this has now been fixed. Moreover, the height metric is now being updated during syncing so you can better see whether your node is almost ready or whether you have time to grab another cup of coffee. Finally, lots of documentation was improved across the snarkVM and snarkOS codebase. Improvements for validators Several improvements were made to harden the security of the consensus algorithm and node implementations. For example, deserialization of nested structs was hardened to reduce the chance of DoS attacks - we thank the anonymous HackerOne submissions for helping to strengthen the Aleo codebase. This PR brought 80%-95% improved RAM usage to load deeply nested programs into memory. Finally, increases in message versions should no longer cause immediate disconnects - they can now be introduced gradually at a future new consensus version. API changes Recall that a Transaction processed by Aleo validators can achieve the following states: accepted: This means that the underlying Deployment or Execution was successful, and that an associated Fee was consumed. The transaction has a confirmed id. rejected: If the Deployment or Execution logic fails, validators will try to process the Fee as an independent Fee transaction. The original transaction is associated with an unconfirmed id, the Fee transaction is associated with a confirmed id. aborted: If the Deployment or Execution logic fails, and the Validators also cannot process the Fee, the transaction is aborted. Tracking accepted and aborted transactions was previously possible, but tracking rejected transactions proved difficult for many ecosystem members. The following endpoint should help resolve this - you can now query an unconfirmed transaction by its confirmed id. GET /{network}/transaction/unconfirmed/:id Closing notes The full changelog for this upcoming release can be found here: https://github.com/ProvableHQ/snarkVM/compare/v3.6.0...canary-v3.7.0 https://github.com/ProvableHQ/snarkOS/compare/v3.6.0...canary-v3.7.0 Contributors A big thank you to all the contributors to this release! @acoglio @d0cd @ljedrz @kaimast @kpandl @lipsyre @ljedrz @lukenewman @mikebenfield @niklaslong @onetrickwolf @raychu86 @vicsn

Deploy Aleo Nodes with One Click on Google Cloud Marketplace

Deploy Aleo Nodes with One Click on Google Cloud Marketplace

Running an Aleo node with snarkOS just got a whole lot faster.

Announcing snarkOS v3.6.x

Announcing snarkOS v3.6.x

The Provable team is happy to announce a new version of the snarkOS Aleo implementation. Aleo is a cryptocurrency enabling developers to build cryptographically secure dApps. You can already use this version on testnet and it is planned to land on mainnet by April 22nd, 2025 - at which point you can also download the release from github. Or, if you’re keen to dive in, build from source anytime you want. Please report any issues you might come across! What's new in v3.6.x snarkVM Consensus changes: increase to 30 validators and spend limits A consensus update is going to take place, allowing the validator count to increase to 30! Extensive load-testing was performed to confirm the robustness of the larger network. In future releases, the validator set will continue to increase in a responsible manner. Excitingly, due to the use of the Bullshark-based AleoBFT consensus algorithm, this increased validator set will increase the throughput of Aleo to around 65 transactions per second! Additionally, spend limits have been introduced, which are discussed in more detail below. The consensus changes will occur at the following block heights: Canary - Block 5_780_000 (~April 11th, 2025 at the current block times) Testnet - Block 6_765_000 (~April 15th, 2025 at the current block times) Mainnet - Block 7_060_000 (~May 4th, 2025 at the current block times) ATTENTION: Validators that do not upgrade in time will be at risk of forking and require manual intervention. Clients that do not upgrade will be at risk of halting until an upgrade occurs. Improvements for validators Initialization runtime performance has improved significantly. Program loading on initialization now avoids an exponential slowdown incurred previously from recursive loading of the same program; and fetching from CDN has been sped up through increased parallelization. Overall runtime performance has also been improved. Validator committees are expensive to construct, and they are now cached in more places. Deployment synthesis has been sped up by almost 2x with help from a statically allocated vector and further allocation reductions. Peering and syncing logic has been overhauled to be more robust. Finally, proposal spend limits have been introduced to limit the maximum blocktime. Validator storage changes This PR fixed the storage path configuration for the proposal cache for validators, to ensure it is stored in the location indicated by the --storage flag. Previously, it was always stored in the default Aleo ledger directory. Validators using this flag should review whether they are backing up the entire indicated folder. Improvements for provers Support for CUDA has been merged which will speed up running a snarkOS prover out of the box. API changes This PR is an initial iteration of a validator telemetry implementation used for tracking metrics and performance of other validators. This will allow validators to better monitor the behavior of its peers (and itself) and react accordingly - directly via connections or off-chain via alerts. This new feature is currently guarded with a new telemetry feature flag for optional use by validators. There is a rudimentary concept of participation score that is exposed via logs and a new REST api: // GET /{network}/validators/participation // GET /{network}/validators/participation?metadata={true} Improvements for developers A locktick feature has been added which allows for logging of currently-held locks. This has proven extremely useful for hunting down deadlocks. Cargo doc now compiles again! Moreover, many parts of the codebase have been documented in much more detail - this ongoing documentation effort will improve the developer experience for new contributors. A regression testing suite has been developed to ensure all deployed programs continue to be valid on new versions of snarkVM - ensuring for example that R1CS synthesis does not change. Moreover, a small devnet is now automatically launched in CI on every open PR, catching more issues in a fully automated way. Closing notes This release, there is no update required for Leo, but a new release is on its way bringing several exciting updates, so stay tuned. The full changelog for this upcoming release can be found here: https://github.com/ProvableHQ/snarkVM/compare/v1.4.0...a296d35 https://github.com/ProvableHQ/snarkOS/compare/v3.4.0...a1e4a28 Contributors A big thank you to all the contributors to this release! @acoglio @d0cd @ljedrz @kaimast @kpandl @mikebenfield @niklaslong @onetrickwolf @raychu86 @vicsn

Announcing snarkOS v3.4.x

Announcing snarkOS v3.4.x

The Provable team is happy to announce a new version of the snarkOS Aleo implementation. Aleo is a cryptocurrency enabling developers to build cryptographically secure dApps. You can already use this version on testnet and it is planned to land on mainnet by March 25th, 2025 - at which point you can also download the release from github. Or, if you’re keen to dive in, build from source anytime you want. Please report any issues you might come across! What's new in v3.4.x Performance improvements for end users The snarkVM library now avoids synthesis of imported deployments, leading to an exponential speedup in prover time. Previously, when trying to deploy a program with many imports, synthesis time could take many hours - now it will be done in seconds. Let’s explain. Synthesis is the process of transforming high level aleo instructions to a set of constraints (expressed in R1CS). As a result of this synthesis, transaction execution can be proved using zk-SNARKs. Even transactions expressing truly enormous state updates are small, can be verified ultra-fast, and, most importantly, keep user data private from the network. Previously, for every deployment, every imported function was synthesized; even if those imports had already been previously deployed and their constraint representation was known. The fix entailed refactoring the AleoVM to skip full circuit synthesis for imports and to produce “dummy” outputs with consistent record nonces for imported functions, allowing synthesis of the root function to continue. Performance improvements for validators Validator block production is much faster due to caching of fee verification, faster Merkle root computation and generally more greedy verification of executions. These speedups are an essential part of scaling up the validator set in future releases. API changes Support was added for GET /{network}/block/{height}/header in this PR. With this it is possible to query only the headers for blocks. This will reduce both bandwidth and payload sizes for the one parsing the result. Other changes The validator and client syncing logic has improved documentation and is being refactored bit by bit, allowing future releases to introduce further speed improvements. This release, there is no update required for Leo, the programming language allowing you to write, deploy and execute programs on Aleo. Several exciting updates are underway, so stay tuned. The full changelog can be found here: https://github.com/ProvableHQ/snarkVM/compare/v1.3.0...3ced248 https://github.com/ProvableHQ/snarkOS/compare/v3.3.2...ac316221d Contributors to v3.4.x A big thank you to all the contributors! @acoglio @d0cd @elderhammer @giddie @ljedrz @joske @kpandl @meetrick @niklaslong @raphexion @raychu86 @ungaro @vicsn @zosorock

The Leo programming language: fast, safe and worth the await! 🦁

The Leo programming language: fast, safe and worth the await! 🦁

TL;DR Leo is a statically-typed programming language for private smart contracts designed for intuitive Aleo blockchain development. It is powered by ZK, with unique syntax to compose on-chain and off-chain logic. What the heck is even a Leo? Most features you’re used to from smart contracts can be expressed in Leo. You can define a cryptocurrency program which mints, transfers and airdrops tokens; you can define a voting program, or a DAO; and much more. However, in contrast to, for example, Bitcoin or Ethereum transactions, users do not send signed instructions into the network for execution. Users execute the code off-chain and send, on-chain, a zero-knowledge proof (or more technically, a SNARK) of the off-chain execution. This is possible because, under the hood, Leo program functions compile to a set of constraints (expressed in R1CS). As a result, even transactions expressing truly enormous state updates are small, can be verified ultra-fast, and, most importantly, keep user data private from the network. Very cool bro, but why create a whole new language? The first version of Leo was released back in 2020, making it one of the first ZK programming languages, and it still shines today on three fronts: proving speed, safety, and developer experience. Leo Advantage #1: Fast proving speed Despite the magic of zero-knowledge proofs, they have a drawback: they require a lot of computational power to create. A very optimistic estimate of future ZK systems is that they’ll still incur a 1000x proving overhead over native computation (assuming similar hardware). A custom “zk-friendly” “zk-DSL” language is essential to minimize the footprint of the function when expressed as constraints and to speed up proving. Despite the breathtaking and amazing progress in the last couple of years proving Solidity or Rust logic (almost) out of the box, such “zk-VM”-based approaches still lag behind on performance. Over the last few years, many exciting new proof systems have emerged, and due to the Leo compiler’s modular nature, the existing Varuna proof system can easily be swapped with a more novel proof system, while retaining the benefit of constraint-optimized compilation. Leo Advantage #2: Safety The number one challenge facing blockchain developers is a lack of safety. Smart contract and bridge hacks are responsible for more losses than anything else. Expressing transactions as zero-knowledge proofs adds an extra security risk: if an invalid state becomes accepted, there could be hidden inflation, similar to the Zcash inflation bug in their proof system. In order to minimise security risks, various parts of the Aleo toolchain have been formally modeled and verified. In the future, Leo will also fulfill its promise of utilizing a formally verifying compiler. Keeping the language footprint small is essential to achieve that goal. Cryptography researcher Thaler mentions that a big advantage of proving statements about programs built in pre-existing languages like Rust is that its creators don't have to build their own compiler. However, it’s worth taking into consideration that the majority of compiler logic of pre-existing languages is not relevant in the context of generating proofs. Rust's most complex and useful feature - memory safety - is not by itself meaningful in the context of generating a proof. Neither is language syntax related to concurrency. Going one level lower, a significant portion of compiler middleware is dedicated to hardware-independent and hardware-dependent optimizations. While these optimizations are essential if you want to prove statements about, e.g., the Rust programming language, it would be silly for a zk-VM to reflect all of that logic if you have no intention of proving statements about Rust programs. Moreover, the added logic introduces a ton of chance for bugs: “Even with conservative estimates, every month, there should be at least a dozen new known vulnerabilities likely to lead to an exploit in a formally verified RISC-V ZKVM, where proofs are verified against assembly generated by one of the two major compilers (GCC or LLVM). This does not count unreported bugs.” (source) Leo Advantage #3: Developer experience Third, the developer experience. Leo's main purpose is to generate proofs on the Aleo cryptocurrency network, and its async-await syntax explicitly models moving data between an on-chain and off-chain environment. “The unique part of Leo is that it separates transition and function. The transition is executed off-chain with privacy. The correctness of the execution is proved by a zero-knowledge proof and verified by the network. All the inputs [...] and the intermediate variables are hidden by default. The function is executed publicly on-chain so that it can read and write the public state on-chain.” - (source) Async functions are executed publicly. Async transitions can call async functions. A call to an async function returns a Future object. It is asynchronous because the code gets executed at a later point in time. Async functions are atomic; they either succeed or fail, and the state is reverted if they fail. Which apps can be built with Leo? Smart contracts are powerful tools, allowing users to manipulate on-chain state without permission and powering crazy economic concepts such as Flash Loans, Time-locked Liquidity and Continuous Auctions. As Tarun mentioned, DeFi intrinsically embeds collateral reqs. By adding the power of zero-knowledge proofs, that collateral can now also be privately owned. Add oracles on top, and we can do private credit scoring, private auctions, private DeFi vaults, and much more. Today, Aleo is live with the liquid staking protocol Pondo, Automated Market Makers, and many more applications built with Leo. In the Future, Leo will become ever more performant, safe and easy to use. To meet the vibrant developer community, come and follow: Leo Telegram Leo Discord Leo’s Github Repository Leo’s documentation: https://docs.leo-lang.org

Aleo Network Foundation and Provable Collaborate with Google Cloud to Scale the Layer 1 ZK Privacy-Focused Network

Aleo Network Foundation and Provable Collaborate with Google Cloud to Scale the Layer 1 ZK Privacy-Focused Network

Aleo becomes one of the first zero-knowledge and privacy-first Layer 1 blockchain networks to integrate with Google Cloud, reinforcing its leadership in the growing ZK ecosystem.

Announcing snarkOS v3.3.0

Announcing snarkOS v3.3.0

The Provable team is happy to announce a new version of the snarkOS Aleo implementation. Aleo is a cryptocurrency enabling developers to build cryptographically secure dApps. You can already use this version on testnet (build from source on the commit d269988) - it is planned to land on mainnet by February 11th, 2025, when v3.3.0 will also be available as a release from GitHub. Please report any issues you might come across! What's new in v3.3.0 snarkVM Consensus Changes: increase to 25 validators A consensus update is going to take place, allowing the validator count to increase to 25! Extensive load-testing was performed to confirm the robustness of the larger network. In future releases, the validator set will continue to increase in a responsible manner. Excitingly, due to the use of the Bullshark-based AleoBFT consensus algorithm, this increased validator set will increase the throughput of Aleo to around 50 transactions per second! The consensus changes will occur at the following block heights: Canary - Block 4,560,000 (~Jan 25, 2025 at the current 4s block times) Testnet - Block 4,800,000 (~Jan 31, 2025 at the current 3.4s block times) Mainnet - Block 4,900,000 (~Feb 18, 2025 at the current 3.0s block times) ATTENTION: Validators that do not upgrade in time will be at risk of forking and require manual intervention. Clients that do not upgrade will be at risk of halting until an upgrade occurs. Syncing close to tip many times faster Whenever a validator or client is lagging behind, they request blocks from other peers. This process had a subtle bug which caused many seconds of delay on fresh requests. Now that this has been fixed, syncing will be multiple times faster. (PR). Other changes Previously, the 'snarkos developer scan' command was broken because it used an outdated endpoint internally. This is now fixed (PR). Various performance and documentation improvements were included, such as adding a cache for block requests (PR). Validators will consume slightly more memory, but this should be offset in the near future by deployments no longer being held in memory (WIP PR). This release, there is no update required for Leo, the programming language allowing you to write, deploy and execute programs on Aleo. Several exciting updates are underway, so stay tuned. Contributors to v3.3.0 A big thank you to all the contributors to v3.3.0! @acoglio @d0cd @ljedrz @kaxxa123 @kpandl @niklaslong @raychu86 @vicsn

Programs
credits.aleo
33,720,992 CALLS
puzzle_arcade_coin_v002.aleo
7,757,527 CALLS
token_registry.aleo
6,552,383 CALLS
puzzle_arcade_ticket_v002.aleo
1,464,517 CALLS
pondo_protocol.aleo
1,462,324 CALLS
Validators
aleo1n6c5ugxk6tp09vkrjegcpcprssdfcf7283agcdtt8gu9qex2c5xs9c28ay
TVL $42,801,716
aleo1m5vc6da037erge36scdmefk0dcnrjk9tu04zyedfvxunwcwd3vxqtcy7ln
Coinbase
TVL $33,526,235
aleo1vfukg8ky2mhfprw63s0k0hl4vvd8573s6fkn8cv9y0ca6q27eq8qwdnxls
Coinbase
TVL $32,589,044
aleo14pscusweq2ggydxh3lzycem0r897dl4thk64aqf6ap7yjp25t5fqnnepxu
TVL $19,175,135
aleo1q3vx8pet0h7739hx5xlekfxh9kus6qdlxhx9qdkxhh9rnva8q5gsskve3t
Figment
TVL $15,540,502
DeFi
PondoPondo
TVL $11,287,577
Beta StakingBeta Staking
TVL $3,298,107
VerulinkVerulink
TVL $2,823,022
AlphaSwapAlphaSwap
TVL $511,166
Arcane FinanceArcane Finance
TVL $315,709

Want to build cryptographically secure dApps at scale?

Use the Provable SDK to build secure, private applications on Aleo. Empowering digital privacy.Learn more

Latest Blocks

38s ago
9,034,844
mainnet
1 activity
40s ago
9,034,843
mainnet
0 activities
42s ago
9,034,842
mainnet
1 activity
44s ago
9,034,841
mainnet
1 activity
46s ago
9,034,840
mainnet
0 activities
48s ago
9,034,839
mainnet
0 activities
50s ago
9,034,838
mainnet
0 activities
52s ago
9,034,837
mainnet
1 activity
54s ago
9,034,836
mainnet
3 activities
56s ago
9,034,835
mainnet
6 activities
1m ago
9,034,834
mainnet
0 activities
1m ago
9,034,833
mainnet
3 activities
1m ago
9,034,832
mainnet
0 activities
1m ago
9,034,831
mainnet
1 activity
1m ago
9,034,830
mainnet
4 activities
1m ago
9,034,829
mainnet
1 activity
1m ago
9,034,828
mainnet
0 activities
1m ago
9,034,827
mainnet
0 activities
1m ago
9,034,826
mainnet
5 activities
1m ago
9,034,825
mainnet
0 activities
2m ago
9,034,824
mainnet
1 activity
2m ago
9,034,823
mainnet
0 activities
2m ago
9,034,822
mainnet
1 activity
2m ago
9,034,821
mainnet
0 activities
2m ago
9,034,820
mainnet
0 activities

Latest Transactions

Transaction IDStatusFunctionIn BlockTypeAge
at1tdeg3hp8l8quuj24yewnf6x9hyrrg4asetyrjyrwe48rrf6legrsc7vgp0
accepted
mint
9,034,842
Execute
<1 min
at1s03708n0fdhss6mp3t70huv20dvq5edhrdtkakhaa4w4v6cytgzqk5sa9n
accepted
transfer​_public
9,034,841
Execute
<1 min
at165gwc9pufs30rwrmqkmhv85jdzzgp7tyd5dgxyhrz6jnj2anugyqyxdtft
accepted
transfer​_public
9,034,836
Execute
<1 min
at1c3wh35wdhp4r8xu9mduknvvdces5406duxlnam7lvq9hfd2kgsxq0vsucp
accepted
transfer​_public
9,034,836
Execute
<1 min
at1zdweucj9m60yvtpn0qy9mlu83ws0f6l730kl0fvuc06e8r0q0qrqxtkc52
accepted
transfer​_public
9,034,836
Execute
<1 min
at10c9nqk2n5r97dscwdhjnnf86jss747utm2yn8pac89w5zff0sgyq5aaxye
accepted
mint
9,034,835
Execute
<1 min
at15qy36e26sztw6qtpfy0mm5s0csfzjk8v4wckq6pg2yqlh4e43c8q0tcukr
accepted
mint
9,034,835
Execute
<1 min
at16ua4mhm7z0mphzcsszxs6w5n70hr88yvel6ah99j3st3qaytgqgsaqpxn0
accepted
mint
9,034,835
Execute
<1 min
at1nep38yh3wz42ahauc5kxj6gtslnptv6tw6atrq76gplk8pgx0c9qrvm7xd
accepted
mint
9,034,835
Execute
<1 min
at1ufx3qrath5sew9d8fwk0qpw0ylp5pegaavnk6grlwk6g48a5xvfq69rar0
accepted
mint
9,034,835
Execute
<1 min