The Async VM (AVM) is our flagship innovation, and it's designed to power the next generation of smart contracts. It's similar to Ethereum's virtual machine (EVM) in many ways, but it's not a fork of the EVM and it introduces unique concepts that require a slightly different way of thinking when building decentralized applications.
What is the Async VM?
The AVM is a full-featured virtual machine with a rich set of instructions that can execute complex logic in a deterministic and trustless environment. The instructions are designed to be as simple as possible, so they're easy to understand and reason about. In the AVM, like in other popular blockchain VMs, the stack stores data and controls the flow of execution.
Unlike other smart contract platforms, the AVM doesn't use a global stack. Instead, each account has its own execution stack, and each message is executed on its own stack. This means that the network can execute messages asynchronously, and each of those executions can further spawn reactive executions elsewhere in the system. It also allows contracts to schedule code to run at a specific time in the future, which opens the door to a wide range of use cases. It's easy to see how this model adds utility that the synchronous execution engines of other blockchains simply can't offer.
Contract executions can spawn reactive executions that can spawn more reactive executions, and so on. This is due to the event-driven nature of the system, and it's one of the most powerful features of the AVM. It allows developers to build complex systems that can react to arbitrary events in real-time, and it opens the door to a wide range of use cases.
It's worth pointing out that the number of reactive executions that can be spawned is inherently limited by the heat tolerance available to the downstream listeners. This means that while it's not technically disallowed, it's not economically feasible for a single contract to spawn an infinite number of reactive executions. This is a good thing, because it prevents the system's resources from being monopolized by buggy or malicious contracts.
The Power of Async
The AVM's asynchronous execution engine is based on the actor model. In this model, each account is an actor that can send and receive messages to and from other actors in the system. Each account effectively has its own private state and its own message queue. When an account receives a message, it's placed into the account's queue until a validator executes the code associated with that message. The validator executes the code and then sends a response back to the sender. This response is placed into the sender's queue, and the sender can then process the response however it sees fit.
The AVM's unique architecture allows for an inherently more efficient and scalable network. It also enables smart contract automation through on-chain event listeners and scheduled execution, as well as provably secure on-chain randomness.
When a remote contract function call is prepended with the
Async-first development made easy
Thinking asynchronously is hard. Pyro leans heavily on popular Web 2.0 programming languages and supports features like an
await keyword and event hooks that help developers write robust, asynchronous code that feels a lot like Typescript and is easy to understand.
If you're familiar with the EVM, you might be wondering how the AVM handles the
call opcode. The AVM's
call opcode is similar to that of the EVM, but it's not a direct replacement. The AVM's
call opcode is asynchronous, and it's designed to call remote functions on other contracts. If access to the result of the remote call is necessary, the
await keyword can be used to suspend the current execution context until the remote function call is complete. This is similar to the
On-chain event listeners
On-chain event listeners are a powerful pattern that allows smart contracts to react to events that occur across the network. For example, a smart contract could listen for a specific event on another smart contract and then perform some action when that event occurs. Event-driven patterns are difficult or impossible to implement on other blockchains because of the synchronous nature of smart contract execution. Thanks to the asynchronous, event-driven design of the AVM, it's easy to listen for events on other contracts. This is a powerful pattern that enables a wide range of use cases, like reactive execution, portfolio automation, real-time arbitrage, and dynamic governance.
Smart contracts can schedule code to run at a specific time in the future. For example, a smart contract could delay its response to a transaction for a few blocks, or it could schedule a recurring execution at a specific interval. This opens the door to interesting things like stronger finality guarantees, governance automation, scheduled payments, and time-based state changes.
Provably secure on-chain randomness
The AVM is capable of generating provably secure random numbers on-chain. This is a powerful feature that breaks down one of the most challenging barriers to Web3 adoption. The AVM's on-chain randomness relies on the fact that requests are resolved asynchronously, and that latency guarantees that a sufficiently unpredictable seed can be generated from the system's Verifiable Random Function (VRF) algorithm at the time of execution. This means that Firechain smart contracts can access provably secure random numbers on-demand without relying on an external source of randomness, like a trusted oracle or a centralized random number generator.