Fe is an emerging smart contract language for the Ethereum blockchain.
NOTE:The larger part of themaster
branch will be replaced with the brand-new implementation, which is currently under development in thefe-v2branch. Please refer to the branch if you kindly contribute to Fe
Fe is a statically typed language for the Ethereum Virtual Machine (EVM). It is inspired by Python and Rust which makes it easy to learn -- especially for new developers entering the Ethereum ecosystem.
- Bounds and overflow checking
- Decidability by limitation of dynamic program behavior
- More precise gas estimation (as a consequence of decidability)
- Static typing
- Pure function support
- Restrictions on reentrancy
- Static looping
- Module imports
- Standard library
- Usage ofYULIR to target both EVM and eWASM
- WASM compiler binaries for enhanced portability and in-browser compilation of Fe contracts
- Implementation in a powerful, systems-oriented language (Rust) with strong safety guarantees to reduce risk of compiler bugs
Additional information about design goals and background can be found in theofficial announcement.
We aim to provide a full language specification that should eventually be used to formally verify the correctness of the compiler. A work in progress draft of the specification can be foundhere.
Fe development is still in its early stages. We have a basicRoadmap for 2021that we want to follow. We generally try to drive the development by working through real world use cases. Our next goal is to provide a working Uniswap implementation in Fe which will help us to advance and form the language.
Fe had its first Alpha release January 2021 and is now following a monthly release cycle.
To compile Fe code:
- Run
fe path/to/fe_source.fe
- Fe creates a directory
output
in the current working directory that contains the compiled binary and abi.
Runfe --help
to explore further options.
The following is a simple contract implemented in Fe.
struct Signed {
pub book_msg: String<100>
}
contract GuestBook {
messages: Map<address, String<100>>
pub fn sign(mut self, mut ctx: Context, book_msg: String<100>) {
self.messages[ctx.msg_sender()] = book_msg
ctx.emit(Signed(book_msg: book_msg))
}
pub fn get_msg(self, addr: address) -> String<100> {
return self.messages[addr].to_mem()
}
}
A lot more working examples can be found in ourtest fixtures directory.
The most advanced example that we can provide at this point is an implementation of theUniswap-V2 core contracts.
- Twitter:@official_fe
- Chat:Discord
The Fe implementation is split into several crates. Crates that depend on the
solidity compiler (directly or indirectly) are licensed GPL-3.0-or-later. This
includes thefe
CLI tool, yulc, driver, tests, and test-utils.
The remaining crates are licensed Apache-2.0. This includes the parser, analyzer, mir, abi, and common.