Skip to content

Changelog

All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

Unreleased

Added

Changed

Removed

7.0.0

Added

  • Added support for EXIT opcode via exit : (string) => 'a function (behaves same as ABORT, but consumes all gas).
  • Compiler warnings for the following: shadowing, negative spends, division by zero, unused functions, unused includes, unused stateful annotations, unused variables, unused parameters, unused user-defined type, dead return value.
  • The pipe operator |> 
    [1, 2, 3] |> List.first |> Option.is_some  // Option.is_some(List.first([1, 2, 3]))
  • Allow binary operators to be used as lambdas 
    function sum(l : list(int)) : int = foldl((+), 0, l)
function logical_and(x, y) = (&&)(x, y)
  • Contract interfaces polymorphism

Changed

  • Error messages have been restructured (less newlines) to provide more unified errors. Also pp_oneline/1 has been added.
  • Ban empty record definitions (e.g. record r = {} would give an error).

Removed

  • Support for AEVM has been entirely wiped

6.1.0 - 2021-10-20

Added

  • Bitwise stdlib
  • Set stdlib
  • Option.force_msg
  • Loading namespaces into the current scope (e.g. using Pair)
  • Assign patterns to variables (e.g. let x::(t = y::_) = [1, 2, 3, 4] where t == [2, 3, 4])
  • Add builtin types (AENS.name, AENS.pointee, Chain.ttl, Chain.base_tx, Chain.ga_meta_tx, Chain.paying_for_tx) to the calldata and result decoder
  • Patterns guards 
    switch(x)
  a::[] | a > 10 => 1
  _              => 2

    function
  f(a::[]) | a > 10 = 1
  f(_)              = 2

Changed

  • Fixed the ACI renderer, it shouldn't drop the stateful modifier

6.0.2 2021-07-05

Changed

  • List.from_to_step now forbids non-positive step (this change does not alter the behavior of the previously deployed contracts)
  • Fixed leaking state between contracts

6.0.1 2021-06-24

Changed

  • Fixed a bug in calldata encoding for contracts containing multiple contracts
  • Fixed a missing include in the Frac standard library

6.0.0 2021-05-26

Added

  • Child contracts
  • Chain.clone
  • Chain.create
  • Chain.bytecode_hash
  • Minor support for variadic functions
  • void type that represents an empty type
  • Call.fee builtin

Changed

  • Contract interfaces must be now invocated by contract interface keywords
  • main keyword to indicate the main contract in case there are child contracts around
  • List.sum and List.product no longer use List.foldl

Removed

5.0.0 2021-04-30

Added

  • A new and improved String standard library has been added. Use it by include "String.aes". It includes functions for turning strings into lists of characters for detailed manipulation. For example: 
    include "String.aes"
contract C =
  entrypoint filter_all_a(s: string) : string =
    String.from_list(List.filter((c : char) => c != 'a', String.to_list(s)))
    will return a list with all a's removed.

There are also convenience functions split, concat, to_upper, to_lower, etc.

All String functions in FATEv2 operate on unicode code points. - Operations for pairing-based cryptography has been added the operations are in the standard library BLS12_381. With these operations it is possible to do Zero Knowledge-proofs, etc. The operations are for the BLS12-381 curve (as the name suggests). - Calls to functions in other contracts (i.e. remote calls) can now be protected. If a contract call fails for any reason (for instance, the remote contract crashes or runs out of gas, or the entrypoint doesn't exist or has the wrong type) the parent call also fails. To make it possible to recover from failures, contract calls takes a named argument protected : bool (default false).

If protected = true the result of the contract call is wrapped in an option, and Some(value) indicates a succesful execution and None indicates that the contract call failed. Note: any gas consumed until the failure is still charged, but all side effects in the remote contract are rolled back on failure. - A new chain operation AENS.update is supported. - New chain exploring operations AENS.lookup and Oracle.expiry to look up an AENS record and the expiry of an Oracle respectively, are added. - Transaction introspection (Auth.tx) has been added. When a Generalized account is authorized, the authorization function needs access to the transaction (and the transaction hash) for the wrapped transaction. The transaction and the transaction hash is available Auth.tx, it is only available during authentication if invoked by a normal contract call it returns None. Example: 

switch(Auth.tx)
  None      => abort("Not in Auth context")
  Some(tx0) =>
    switch(tx0.tx)
      Chain.SpendTx(_, amount, _)  => amount > 400
      Chain.ContractCallTx(_, _)   => true
      _                            => false
- A debug mode is a added to the compiler. Right now its only use is to turn off hermetization.

Changed

  • The function Chain.block_hash(height) is now (in FATEv2) defined for the current height - this used to be an error.
  • Standard library: Sort is optimized to do mergesort and a contains function is added.
  • Improved type errors and explicit errors for some syntax errors (empty code blocks, etc.).
  • Compiler optimization: The ACI is generated alongside bytecode. This means that multiple compiler passes can be avoided.
  • Compiler optimization: Improved parsing (less stack used when transpiled).
  • A bug where constraints were handled out of order fixed.
  • Fixed calldata decoding for singleton records.
  • Improved the documentation w.r.t. signatures, especially stressing the fact that the network ID is a part of what is signed.

Removed

4.3.0

Added

  • Added documentation (moved from protocol)
  • Frac.aes – library for rational numbers
  • Added some more meaningful error messages
  • Exported several parsing functionalities
  • With option keep_included it is possible to see which files were included during the parse
  • There is a function run_parser that be used to evaluate any parsing rule
  • Exported parsers: body, type and decl

Changed

  • Performance improvements in the standard library
  • Fixed ACI encoder to handle - unary operator
  • Fixed including by absolute path
  • Fixed variant type printing in the ACI error messages
  • Fixed pretty printing of combined function clauses

Removed

  • let definitions are no longer supported in the toplevel of the contract
  • type declarations are no longer supported

4.2.0 - 2020-01-15

Added

  • Allow separate entrypoint/function type signature and definition, and pattern matching in left-hand sides: 
      function
    length : list('a) => int
    length([])      = 0
    length(x :: xs) = 1 + length(xs)
  • Allow pattern matching in list comprehension generators (filtering out match failures): 
      function somes(xs : list(option('a))) : list('a) =
    [ x | Some(x) <- xs ]
  • Allow pattern matching in let-bindings (aborting on match failures): 
      function test(m : map(int, int)) =
      let Some(x) = Map.lookup(m, 0)
      x

Changed

  • FATE code generator improvements.
  • Bug fix: Handle qualified constructors in patterns.
  • Bug fix: Allow switching also on negative numbers.

Removed

4.1.0 - 2019-11-26

Added

  • Support encoding and decoding bit fields in call arguments and results.

Changed

  • Various improvements to FATE code generator.

Removed

4.0.0 - 2019-10-11

Added

  • Address.to_contract - casts an address to a (any) contract type.
  • Pragma to check compiler version, e.g. @compiler >= 4.0.
  • Handle numeric escapes, i.e. "\x19Ethereum Signed Message:\n", and similar strings.
  • Bytes.concat and Bytes.split are added to be able to (de-)construct byte arrays.
  • [a..b] language construct, returning the list of numbers between a and b (inclusive). Returns the empty list if a > b.
  • Standard libraries
  • Checks that init is not called from other functions.
  • FATE backend - the compiler is able to produce VM code for both AEVM and FATE. Many of the APIs now take {backend, aevm | fate} to decide wich backend to produce artifacts for.
  • New builtin functions Crypto.ecrecover_secp256k1: (hash, bytes(65)) => option(bytes(20)) and Crypto.ecverify_secp256k1 : (hash, bytes(20), bytes(65)) => bool for recovering and verifying an Ethereum address for a message hash and a signature.
  • Sophia supports list comprehensions known from languages like Python, Haskell or Erlang. Example syntax: 
    [x + y | x <- [1,2,3,4,5], let k = x*x, if (k > 5), y <- [k, k+1, k+2]]
// yields [12,13,14,20,21,22,30,31,32]
  • A new contract, and endpoint, modifier payable is introduced. Contracts, and enpoints, that shall be able to receive funds should be marked as payable. Address.is_payable(a) can be used to check if an (contract) address is payable or not.

Changed

  • Nice type error if contract function is called as from a namespace.
  • Fail on function definitions in contracts other than the main contract.
  • Bug fix in variable optimization - don't discard writes to the store/state.
  • Bug fixes in error reporting.
  • Bug fix in variable liveness analysis for FATE.
  • Error messages are changed into a uniform format, and more helpful messages have been added.
  • Crypto.<hash_fun> and String.<hash_fun> for byte arrays now only hash the actual byte array - not the internal ABI format.
  • More strict checks for polymorphic oracles and higher order oracles and entrypoints.
  • AENS.claim is updated with a NameFee field - to be able to do name auctions within contracts.
  • Fixed a bug in Bytes.to_str for AEVM.
  • New syntax for tuple types. Now 0-tuple type is encoded as unit instead of () and regular tuples are encoded by interspersing inner types with *, for instance int * string. Parens are not necessary. Note it only affects the types, values remain as their were before, so (1, "a") : int * string
  • The AENS.transfer and AENS.revoke functions have been updated to take a name string instead of a name hash.
  • Fixed a bug where the AEVM backend complained about a missing init function when trying to generate calldata from an ACI-generated interface.
  • Compiler now returns the ABI-version in the compiler result map.
  • Renamed Crypto.ecverify and Crypto.ecverify_secp256k1 into Crypto.verify_sig and Crypto.verify_sig_secp256k1 respectively.

Removed

3.2.0 - 2019-06-28

Added

  • New builtin function require : (bool, string) => (). Defined as 
    function require(b, err) = if(!b) abort(err)
  • New builtin functions 
    Bytes.to_str : bytes(_) => string
Bytes.to_int : bytes(_) => int
    for converting a byte array to a hex string and interpreting it as a big-endian encoded integer respectively.

Changed

  • Public contract functions must now be declared as entrypoints: 
    contract Example =
  // Exported
  entrypoint exported_fun(x) = local_fun(x)
  // Not exported
  function local_fun(x) = x
    Functions in namespaces still use function (and private function for private functions).
  • The return type of Chain.block_hash(height) has changed, it used to be int, where 0 denoted an incorrect height. New return type is option(hash), where None represents an incorrect height.
  • Event name hashes now use BLAKE2b instead of Keccak256.
  • Fixed bugs when defining record types in namespaces.
  • Fixed a bug in include path handling when passing options to the compiler.

Removed

3.1.0 - 2019-06-03

Added

Changed

  • Keyword indexed is now optional for word typed (bool, int, address, ...) event arguments.
  • State variable pretty printing now produce 'a, 'b, ... instead of '1, '2, ....
  • ACI is restructured and improved:
    • state and event types (if present) now appear at the top level.
    • Namespaces and remote interfaces are no longer ignored.
    • All type definitions are included in the interface rendering.
    • API functions are renamed, new functions are contract_interface and render_aci_json.
  • Fixed a bug in create_calldata/to_sophia_value - it can now handle negative literals.

Removed

3.0.0 - 2019-05-21

Added

  • stateful annotations are now properly enforced. Functions must be marked stateful in order to update the state or spend tokens.
  • Primitives Contract.creator, Address.is_contract, Address.is_oracle, Oracle.check and Oracle.check_query has been added to Sophia.
  • A byte array type bytes(N) has been added to generalize hash (== bytes(32)) and signature (== bytes(64)) and allow for byte arrays of arbitrary fixed length.
  • Crypto.ecverify_secp256k1 has been added.

Changed

  • Address literals (+ Oracle, Oracle query and remote contracts) have been changed from #<hex> to address as ak_<base58check>, oracle ok_<base58check>, oracle query oq_<base58check> and remote contract ct_<base58check>.
  • The compilation and typechecking of letfun (e.g. let m(f, xs) = map(f, xs)) was not working properly and has been fixed.

Removed

  • let rec has been removed from the language, it has never worked.
  • The standalone CLI compiler is served in the repo aeternity/aesophia_cli and has been completely removed from aesophia.

2.1.0 - 2019-04-11

Added

  • Stubs (not yet wired up) for compilation to FATE
  • Add functions specific for Calldata decoding
  • Support for Auth.tx_hash, not available in AEVM until Fortuna release

Changed

  • Improvements to the ACI generator

2.0.0 - 2019-03-11

Added

  • Add Crypto.ecverify to the compiler.
  • Add Crypto.sha3, Crypto.blake2, Crypto.sha256, String.blake2 and String.sha256 to the compiler.
  • Add the bits type for working with bit fields in Sophia.
  • Add Namespaces to Sophia in order to simplify using library contracts, etc.
  • Add a missig type check on the init function - detects programmer errors earlier.
  • Add the ACI (Aeternity Contract Interface) generator.

Changed

  • Use native bit shift operations in builtin functions, reducing gas cost.
  • Improve type checking of record fields - generates more understandable error messages.
  • Improved, more coherent, error messages.
  • Simplify calldata creation - instead of passing a compiled contract, simply pass a (stubbed) contract string.