Smart contracts + provable storage = FVM
Possibilities

The FVM unlocks boundless possibilities, ranging from programmable storage primitives (such as storage bounties, auctions, and more), to cross-chain interoperability bridges (e.g. trustlessly connecting Filecoin with Ethereum, Solana, NEAR, and more), to data-centric Decentralized Autonomous Organizations (DAOs), to Layer 2 solutions (such as reputation systems, data availability sampling, computation fabrics, and incentive-aligned Content Delivery Networks), and more.

Here are some of the things we're excited to see deployed on the Filecoin network. It's up to you to make them happen!

Chat with developers ➝
/// A Filecoin actor brokering decentralized compute jobs.
/// For illustration purposes only.
#[fvm_actor(state=ComputeState, dispatch="method_num")]
impl ComputeActor {


  /// Creates a job with an input DAG, WASM compute logic,
  /// data affinity, geographical bounds, and timeout.
  pub fn create_job(req: CreateJobReq, st: ComputeState)
    -> CreateJobRes { ... }


  /// Allows a compute node to claim a job by proving it
  /// satisfies the requirements and staking collateral.
  pub fn claim_job(req: ClaimJobReq, st: ComputeState)
    -> ClaimJobRes { ... }


  /// Proves that a compute node finished running a job,
  /// posts the result, and claims the reward.
  pub fn prove_done(req: ProveDoneReq, st: ComputeState)
    -> ProveDoneRes { ... }
}
Decentralized Compute
Data DAOs
Enabling L2 networks
Cross-network interoperability bridges
New storage market primitives
Perpetual storage
Replication workers
Repair workers
Staking Protocols
Insurance protocols
Storage derivatives
A robust WASM-based VM

The FVM is a WASM-based polyglot execution environment for IPLD data. It is designed to support native Filecoin actors written in languages that compile to WASM, as well as smart contracts written for foreign runtimes including the Ethereum Virtual Machine (EVM), Secure EcmaScript (SES), and eBPF.

The initial version of the FVM is relatively simple and deliberately conservative in features. This enables developers onboard quickly, and serves as a rock-solid foundation for many innovations to come.

Examples of future ideas include: async programming via continuations/futures, capability-orientation, time-locked transactions (using external beacons), parallel execution, native primitives for cross-chain interoperability, computation correctness proofs, and more.

The reference FVM and SDK are written in Rust. If you'd like to contribute, explore ideas, or build alternative implementations in other languages, please reach out.

View in GitHub ➝
EVM compatibility

The FVM supports EVM smart contracts out of the box. It emulates EVM bytecode at the low-level, supporting contracts written in Solidity, Vyper, and Yul.

You can continue using all the developer tooling you're familiar with: Remix, Truffle, Hardhat, OpenZeppelin SDK, and more. Most smart contracts ported to Filecoin shouldn't require changes nor auditing.

The EVM foreign runtime is based on pre-existing OSS libraries including SputnikVM and revm. It is the first of several foreign runtimes we plan to support.

Support for EVM smart contract deployment is expected to go live in Milestone 2 (see below).

Curious about technical details? Find out more in the EVM <> FVM mapping specification.



//
// The standard ERC-721 contract from OpenZeppelin SDK.
//
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
  using Address for address;
  using Strings for uint256;


  function balanceOf(address owner) public view virtual
    override returns (uint256)
  {
    require(owner != address(0),
      "ERC721: balance query for the zero address");
    return _balances[owner];
  }


  function transferFrom(
    address from,
    address to,
    uint256 tokenId
  ) public virtual override {
    require(_isApprovedOrOwner(_msgSender(), tokenId),
      "ERC721: transfer caller is not owner nor approved");


    _transfer(from, to, tokenId);
  }
}
Roadmap

The Filecoin Virtual Machine is being introduced incrementally. This minimizes the risk of disruption to the network, and gives developers plenty of opportunities to engage early on.

Feb 2022
Milestone 0: Lotus mainnet canaries with FVM support

The reference FVM implementation has been integrated into a fork of Lotus (the Filecoin reference client). A fleet of canary nodes have been launched on mainnet, running WASM-compiled built-in actors on the FVM. The canaries are monitored for consensus faults and to gather telemetry. This milestone is a testing milestone that's critical to collect raw execution data to feed into the overhaul of the gas model, in preparation for user-programmability. It implies no network upgrade.

Mar 2022
Milestone 0.5: Ability to run FVM node and sync mainnet

Any node operator can sync the Filecoin Mainnet using the FVM and Rust built-in actors, integrated in lotus, venus, forest, and fuhon implementations. It implies no network upgrade.

May 2022
Milestone 1: Introduction of non-programmable WASM-based FVM

Mainnet will atomically switch from the current legacy VMs to the WASM-based reference FVM. A new gas model will be activated that accounts for actual WASM execution costs. Only Rust built-in actors will be supported at this time. This milestone requires a network upgrade.

Sep 2022
(Est.)
Milestone 2.1: Ability to deploy native FVM user actors to mainnet

The FVM will become user-programmable for the first time. Developers will be able to deploy custom smart contracts to the Filecoin mainnet through native actors. SDKs, tutorials, and other developer materials will be generally available. This milestone requires a network upgrade.

Sep 2022
(Est.)
Milestone 2.2: Ability to deploy EVM contracts to mainnet

The FVM delivers the first foreign runtime, the EVM runtime. Developers will be able to deploy custom code to the Filecoin mainnet through EVM smart contracts. SDKs, tutorials, and other developer materials will be generally available. This milestone may require a network upgrade (TBD).

    2022
Milestone 3+: Incremental protocol refactors to enhance programmability

A series of incremental protocol upgrades to move system functionality from privileged space to user space. The result will be a lighter and less opinionated base Filecoin protocol, where storage markets, deal-making, incentives, etc. are extensible, modular, and highly customizable through user-deployed actors. Enhanced programmability features such as user-provided cron, async call patterns, and more will start to be developed at this stage.

Get ready to build

Actors are the equivalent of smart contracts in Filecoin. Deploy existing EVM smart contracts as Filecoin actors, or write native actors from scratch using the reference Rust SDK (or create your own SDK!).

Source code

FVM Reference Implementation Follow the development activity on GitHub and stay up to date.

Developer resources

Development activity Follow the development activity on GitHub and stay up to date.Tutorials Coming SoonLearn how to deploy to the FVM with some simple tutorials.

Specifications

FVM Architecture Learn how the FVM works, and the technologies involved.EVM Compatibility Learn how the EVM emulation works within the FVM.

Reference SDK

Rust SDK WIPWrite Filecoin actors in Rust

Community SDKs

AssemblyScript SDK Grant availableInterested in writing Filecoin actors in AssemblyScript? Become an Early Builder and create the SDK yourself!Swift SDK Grant availableInterested in writing Filecoin actors in Swift? Become an Early Builder and create the SDK yourself!Kotlin SDK Grant availableInterested in writing Filecoin actors in Kotlin? Become an Early Builder and create the SDK yourself!Go SDK Grant availableWrite Filecoin actors in Go (TinyGo)? Become an Early Builder and create the SDK yourself!
Dive right in
Apply for the FVM foundry A special program to onboard Early Builders, the pioneering members of the FVM Foundry
Read the specs Learn all about the design of the FVM, how it executes EVM bytecode, and a lot more
Check out the source Explore the codebase of the reference implementation, and contribute fixes, improvements, tools, and docs
Join the discussion Stay up to date, discuss the technology, get feedback, report issues, and more
FVM Bug Bounty Program

The Filecoin VM team invites hackers to help us find potential vulnerabilities in the FVM codebase. The FVM will be added to the live Filecoin network in several milestones.

Bug Bounties are now live for Milestone 1 until the end of May.

Rewards for FVM bug bounties are the same as in the regular bug bounty program for the Filecoin project. To submit a bug report please contact us here.

 

What’s in scope:

  • Ref FVM - reference implementation of the Filecoin VM (specs). Written in Rust and intended to be integrated via FFI into non-Rust Filecoin clients like Lotus.

  • Lotus - Ref FVM integration - integration of the Ref FVM into Lotus via FFI. Written in Go. (The PR listed is merely an entry point into the codebase, but the scope is not limited to it. Please review what's on master and other pending PRs.)

  • Lotus - Filecoin FFI - the FFI glue code. Written in Go and Rust. (As above, the PR linked is merely an entry point, but the scope is not limited to it.)

  • Builtin Actors - written in Rust, WASM-compiled built-in actors (i.e., smart contracts) used by all Filecoin clients. An actors spec and test vectors are available for reference. An executable spec in Go is available at spec-actors — these actors power the live network pre-FVM. (Note that auditing actors normally requires Filecoin domain expertise).

  • Exclusions to Scope including Known Issues are listed here on Github and will be regularly updated.

     

Milestone 1 is scheduled for deployment to Filecoin mainnet in May 2022.

Milestone 2 will introduce EVM-compatibility and user-programmable actors. Milestone 2 will likely be available for bug bounties in July, before deployment to mainnet in September 2022 (estimated).