Skip to content

Latest commit

 

History

History
84 lines (53 loc) · 3.4 KB

README.md

File metadata and controls

84 lines (53 loc) · 3.4 KB
Raw

Fe is an emerging smart contract language for the Ethereum blockchain.

Build Status Coverage

Overview

Fe is a statically typed language for the Ethereum Virtual Machine (EVM). It is inspired by Python and Rust and is easy to learn -- even for developers who are new to the Ethereum ecosystem.

Features & Goals

  • 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
  • Binary fixed-point math
  • Restrictions on reentrancy
  • Static looping
  • Module imports
  • Standard library
  • Usage of YUL IR 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 the official announcement.

Language Specification

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 found here.

Progress

Fe development is still in its early stages. We have a basic Roadmap for 2021 that 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.

Getting started

To compile Fe code:

  1. Run fe path/to/fe_source.fe
  2. Fe creates a directory output in the current working directory that contains the compiled binary and abi.

Run fe --help to explore further options.

Examples

The following is a simple contract implemented in Fe.

type BookMsg = bytes[100]

contract GuestBook:
    pub guest_book: map<address, BookMsg>

    event Signed:
        book_msg: BookMsg

    pub def sign(book_msg: BookMsg):
        self.guest_book[msg.sender] = book_msg

        emit Signed(book_msg=book_msg)

    pub def get_msg(addr: address) -> BookMsg:
        return self.guest_book[addr].to_mem()

A lot more working examples can be found in our test fixtures directory.

The most advanced example that we can provide at this point is a fully working ERC20 implementation.

Community