[Ceres]: Document generic all names delegation signatures (#440)

CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [CERES 8.0.0]
+### Added
+- Bitwise operations for integers: `band`, `bor`, `bxor`, `bnot`, `<<` and `>>`.
+- `Int.mulmod` - combined builtin operation for multiplication and modulus.
+- `Crypto.poseidon` - a ZK/SNARK-friendly hash function (over the BLS12-381 scalar field).
+- `Address.to_bytes` - convert an address to its binary representation (for hashing, etc.).
+- Raw data pointers added to AENS. In short we have introduced a new namespace
+  `AENSv2`; they contain types similar to the old `AENS`; `AENS.name` and
+  `AENS.pointee`, where the latter now has a constructor `DataPt(string)`. All
+  AENS actions have been moved to `AENSv2`, and `AENSv2.lookup` and
+  `AENSv2.update` consume and produce the new types. The old `AENS` namespace
+  only contains the old datatypes, that can be used to interface existing
+  contracts. Standard library `AENSCompat` is added to convert between old and
+  new pointers.
+### Changed
+### Removed
+- `Bitwise.aes` standard library is removed - the builtin operations are superior.
+
 ## [Unreleased]
 ### Added
 - Options to enable/disable certain optimizations.

docs/sophia_features.md

@@ -564,6 +564,14 @@ All operations are *safe* with respect to overflow and underflow.
 The division and modulo operations throw an arithmetic error if the
 right-hand operand is zero.
 
+Sophia arbitrary-sized integers (FATE) also supports the following bitwise operations:
+- bitwise and (`x band y`)
+- bitwise or (`x bor y`)
+- bitwise xor (`x bxor y`)
+- bitwise not (`bnot x`)
+- arithmetic bitshift left (`x << n`)
+- arithmetic bitshift right (`x >> n`)
+
 ## Bit fields
 
 Sophia integers do not support bit arithmetic. Instead there is a separate

docs/sophia_stdlib.md

@@ -14,6 +14,7 @@ The out-of-the-box namespaces are:
 
 - [Address](#address)
 - [AENS](#aens)
+- [AENSv2](#aensv2)
 - [Auth](#auth)
 - [Bits](#bits)
 - [Bytes](#bytes)
@@ -31,6 +32,7 @@ The following ones need to be included as regular files with `.aes` suffix, for
 include "List.aes"
 ```
 
+- [AENSCompat](#aenscompat)
 - [Bitwise](#bitwise)
 - [BLS12_381](#bls12_381)
 - [Func](#func)
@@ -90,13 +92,10 @@ Cast address to contract type C (where `C` is a contract)
 
 ### AENS
 
-The following functionality is available for interacting with the æternity
-naming system (AENS).
-If `owner` is equal to `Contract.address` the signature `signature` is
-ignored, and can be left out since it is a named argument. Otherwise we need
-a signature to prove that we are allowed to do AENS operations on behalf of
-`owner`. The [signature is tied to a network id](https://github.com/aeternity/protocol/blob/iris/consensus/consensus.md#transaction-signature),
-i.e. the signature material should be prefixed by the network id.
+The old AENS namespace, kept in the compiler to be able to interact with
+contracts from before Ceres, compiled using aesophia compiler version 7.x and
+earlier. Used in [AENSCompat](#aenscompat) when converting between old and new
+pointers.
 
 #### Types
 
@@ -113,12 +112,41 @@ datatype pointee = AccountPt(address) | OraclePt(address)
                  | ContractPt(address) | ChannelPt(address)
 ```
 
+### AENSv2
+
+Note: introduced in v8.0
+
+The following functionality is available for interacting with the æternity
+naming system (AENS).  If `owner` is equal to `Contract.address` the signature
+`signature` is ignored, and can be left out since it is a named argument.
+Otherwise we need a signature to prove that we are allowed to do AENS
+operations on behalf of `owner`. The [signature is tied to a network
+id](https://github.com/aeternity/protocol/blob/iris/consensus/consensus.md#transaction-signature),
+i.e. the signature material should be prefixed by the network id.
+
+#### Types
+
+##### name
+```
+datatype name = Name(address, Chain.ttl, map(string, AENSv2.pointee))
+```
+
+
+##### pointee
+
+```
+datatype pointee = AccountPt(address) | OraclePt(address)
+                 | ContractPt(address) | ChannelPt(address) | DataPt(string)
+```
+
+Note: on-chain there is a maximum length enforced for `DataPt`, it is 1024 bytes.
+Sophia itself does _not_ enforce this.
 
 #### Functions
 
 ##### resolve
 ```
-AENS.resolve(name : string, key : string) : option('a)
+AENSv2.resolve(name : string, key : string) : option('a)
 ```
 
 Name resolution. Here `name` should be a registered name and `key` one of the attributes
@@ -129,41 +157,53 @@ type checked against this type at run time.
 
 ##### lookup
 ```
-AENS.lookup(name : string) : option(AENS.name)
+AENSv2.lookup(name : string) : option(AENSv2.name)
 ```
 
-If `name` is an active name `AENS.lookup` returns a name object.
+If `name` is an active name `AENSv2.lookup` returns a name object.
 The three arguments to `Name` are `owner`, `expiry` and a map of the
 `pointees` for the name. Note: the expiry of the name is always a fixed TTL.
 For example:
 ```
-let Some(Name(owner, FixedTTL(expiry), ptrs)) = AENS.lookup("example.chain")
+let Some(AENSv2.Name(owner, FixedTTL(expiry), ptrs)) = AENSv2.lookup("example.chain")
 ```
 
+Note: Changed to produce `AENSv2.name` in v8.0 (Ceres protocol upgrade).
 
 ##### preclaim
 ```
-AENS.preclaim(owner : address, commitment_hash : hash, <signature : signature>) : unit
+AENSv2.preclaim(owner : address, commitment_hash : hash, <signature : signature>) : unit
 ```
 
 The [signature](./sophia_features.md#delegation-signature) should be over
 `network id` + `owner address` + `Contract.address` (concatenated as byte arrays).
 
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. over `network id` + `owner address` + `string "AENS"` +
+`Contract.address`.
+
 
 ##### claim
 ```
-AENS.claim(owner : address, name : string, salt : int, name_fee : int, <signature : signature>) : unit
+AENSv2.claim(owner : address, name : string, salt : int, name_fee : int, <signature : signature>) : unit
 ```
 
 The [signature](./sophia_features.md#delegation-signature) should be over
-`network id` + `owner address` + `name_hash` + `Contract.address`
-(concatenated as byte arrays)
-using the private key of the `owner` account for signing.
+`network id` + `owner address` + `name_hash` + `Contract.address` (concatenated
+as byte arrays) using the private key of the `owner` account for signing.
+
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. over `network id` + `owner address` + `string "AENS"` +
+`Contract.address`.
 
 
 ##### transfer
 ```
-AENS.transfer(owner : address, new_owner : address, name : string, <signature : signature>) : unit
+AENSv2.transfer(owner : address, new_owner : address, name : string, <signature : signature>) : unit
 ```
 
 Transfers name to the new owner.
@@ -173,10 +213,16 @@ The [signature](./sophia_features.md#delegation-signature) should be over
 (concatenated as byte arrays)
 using the private key of the `owner` account for signing.
 
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. over `network id` + `owner address` + `string "AENS"` +
+`Contract.address`.
+
 
 ##### revoke
 ```
-AENS.revoke(owner : address, name : string, <signature : signature>) : unit
+AENSv2.revoke(owner : address, name : string, <signature : signature>) : unit
 ```
 
 Revokes the name to extend the ownership time.
@@ -186,17 +232,24 @@ The [signature](./sophia_features.md#delegation-signature) should be over
 (concatenated as byte arrays)
 using the private key of the `owner` account for signing.
 
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. over `network id` + `owner address` + `string "AENS"` +
+`Contract.address`.
+
 
 ##### update
 ```
-AENS.update(owner : address, name : string, expiry : option(Chain.ttl), client_ttl : option(int),
-            new_ptrs : map(string, AENS.pointee), <signature : signature>) : unit
+AENSv2.update(owner : address, name : string, expiry : option(Chain.ttl), client_ttl : option(int),
+            new_ptrs : map(string, AENSv2.pointee), <signature : signature>) : unit
 ```
 
 Updates the name. If the optional parameters are set to `None` that parameter
 will not be updated, for example if `None` is passed as `expiry` the expiry
 block of the name is not changed.
 
+Note: Changed to consume `AENSv2.pointee` in v8.0 (Ceres protocol upgrade).
 
 ### Auth
 
@@ -236,7 +289,10 @@ namespace Chain =
 Auth.tx_hash : option(hash)
 ```
 
-Gets the transaction hash during authentication.
+Gets the transaction hash during authentication. Note: `Auth.tx_hash`
+computation differs between protocol versions (changed in Ceres!), see
+[aeserialisation](https://github.com/aeternity/protocol/blob/master/serializations.md)
+specification for details.
 
 
 ### Bits
@@ -381,6 +437,12 @@ Call.gas_price : int
 
 The gas price of the current call.
 
+#### mulmod
+```
+Int.mulmod : (a : int, b : int, q : int) : int
+```
+
+Combined multiplication and modulus, returns `(a * b) mod q`.
 
 #### fee
 ```
@@ -469,6 +531,13 @@ Chain.block_height : int"
 
 The height of the current block (i.e. the block in which the current call will be included).
 
+#### to_bytes
+```
+Address.to_bytes(a : address) : bytes(32)
+```
+
+The binary representation of the address.
+
 
 ##### coinbase
 ```
@@ -538,6 +607,13 @@ charging the calling contract. Note that this won't be visible in `Call.value`
 in the `init` call of the new contract. It will be included in
 `Contract.balance`, however.
 
+#### poseidon
+```
+Crypto.poseidon(x1 : int, x2 : int) : int
+```
+
+Hash two integers (in the scalar field of BLS12-381) to another integer (in the scalar
+field of BLS12-281). This is a ZK/SNARK-friendly hash function.
 
 The type `'c` must be instantiated with a contract.
 
@@ -914,88 +990,21 @@ It returns `true` iff the oracle query exist and has the expected type.
 These need to be explicitly included (with `.aes` suffix)
 
 
-### Bitwise
+### AENSCompat
 
-Bitwise operations on arbitrary precision integers.
-
-#### bsr
+#### pointee\_to\_V2
 ```
-Bitwise.bsr(n : int, x : int) : int
+AENSCompat.pointee_to_V2(p : AENS.pointee) : AENSv2.pointee
 ```
 
-Logical bit shift `x` right `n` positions.
+Translate old pointee format to new, this is always possible.
 
-
-#### bsl
+#### pointee\_from\_V2
 ```
-Bitwise.bsl(n : int, x : int) : int
+AENSCompat.pointee_from_V2(p2 : AENSv2.pointee) : option(AENS.pointee)
 ```
 
-Logical bit shift `x` left `n` positions.
-
-
-#### bsli
-```
-Bitwise.bsli(n : int, x : int, lim : int) : int
-```
-
-Logical bit shift `x` left `n` positions, limit to `lim` bits.
-
-
-#### band
-```
-Bitwise.band(x : int, y : int) : int
-```
-
-Bitwise `and` of `x` and `y`.
-
-
-#### bor
-```
-Bitwise.bor(x : int, y : int) : int
-```
-
-Bitwise `or` of `x` and `y`.
-
-
-#### bxor
-```
-Bitwise.bxor(x : int, y : int) : int
-```
-
-Bitwise `xor` of `x` and `y`.
-
-
-#### bnot
-```
-Bitwise.bnot(x : int) : int
-```
-
-Bitwise `not` of `x`. Defined and implemented as `bnot(x) = bxor(x, -1)`.
-
-
-#### uband
-```
-Bitwise.uband(x : int, y : int) : int
-```
-
-Bitwise `and` of _non-negative_ numbers `x` and `y`.
-
-
-#### ubor
-```
-Bitwise.ubor(x : int, y : int) : int
-```
-
-Bitwise `or` of _non-negative_ `x` and `y`.
-
-
-#### ubxor
-```
-Bitwise.ubxor(x : int, y : int) : int
-```
-
-Bitwise `xor` of _non-negative_ `x` and `y`.
+Translate new pointee format to old, `DataPt` can't be translated, so `None` is returned in this case.
 
 
 ### BLS12\_381

docs/sophia_syntax.md

@@ -254,8 +254,8 @@ Path ::= Id                 // Record field
 
 BinOp ::= '||' | '&&' | '<' | '>' | '=<' | '>=' | '==' | '!='
         | '::' | '++' | '+' | '-' | '*' | '/' | 'mod' | '^'
-        | '|>'
-UnOp  ::= '-' | '!'
+        | 'band' | 'bor' | 'bxor' | '<<' | '>>' | '|>'
+UnOp  ::= '-' | '!' | 'bnot'
 ```
 
 ## Operators types
@@ -264,6 +264,7 @@ UnOp  ::= '-' | '!'
 | --- | ---
 | `-` `+` `*` `/` `mod` `^` | arithmetic operators
 | `!` `&&` `||` | logical operators
+| `band` `bor` `bxor` `bnot` `<<` `>>` | bitwise operators
 | `==` `!=` `<` `>` `=<` `>=` | comparison operators
 | `::` `++` | list operators
 | `|>` | functional operators
@@ -274,13 +275,17 @@ In order of highest to lowest precedence.
 
 | Operators | Associativity
 | --- | ---
-| `!` | right
+| `!` `bnot`| right
 | `^` | left
 | `*` `/` `mod` | left
 | `-` (unary) | right
 | `+` `-` | left
+| `<<` `>>` | left
 | `::` `++` | right
 | `<` `>` `=<` `>=` `==` `!=` | none
+| `band` | left
+| `bxor` | left
+| `bor` | left
 | `&&` | right
 | `||` | right
 | `|>` | left

priv/stdlib/AENSCompat.aes

@@ -0,0 +1,17 @@
+namespace AENSCompat =
+  // Translate old format to new format - always possible
+  function pointee_to_V2(p : AENS.pointee) : AENSv2.pointee =
+    switch(p)
+      AENS.AccountPt(a)  => AENSv2.AccountPt(a)
+      AENS.OraclePt(a)   => AENSv2.OraclePt(a)
+      AENS.ContractPt(a) => AENSv2.ContractPt(a)
+      AENS.ChannelPt(a)  => AENSv2.ChannelPt(a)
+
+  // Translate new format to old format - option type!
+  function pointee_from_V2(p2 : AENSv2.pointee) : option(AENS.pointee) =
+    switch(p2)
+      AENSv2.AccountPt(a)  => Some(AENS.AccountPt(a))
+      AENSv2.OraclePt(a)   => Some(AENS.OraclePt(a))
+      AENSv2.ContractPt(a) => Some(AENS.ContractPt(a))
+      AENSv2.ChannelPt(a)  => Some(AENS.ChannelPt(a))
+      AENSv2.DataPt(_)     => None

priv/stdlib/Bitwise.aes

@@ -1,126 +0,0 @@
-@compiler >= 4.3
-
-namespace Bitwise =
-
-  // bit shift 'x' right 'n' postions
-  function bsr(n : int, x : int) : int =
-    let step = 2^n
-    let res  = x / step
-    if (x >= 0 || x mod step == 0)
-      res
-    else
-      res - 1
-
-  // bit shift 'x' left 'n' positions
-  function bsl(n : int, x : int) : int =
-    x * 2^n
-
-  // bit shift 'x' left 'n' positions, limit at 'lim' bits
-  function bsli(n : int, x : int, lim : int) : int =
-    (x * 2^n) mod (2^lim)
-
-  // bitwise 'and' for arbitrary precision integers
-  function band(a : int, b : int) : int =
-      if (a >= 0 && b >= 0)
-        uband_(a, b)
-      elif (b >= 0)
-        ubnand_(b, -1 - a)
-      elif (a >= 0)
-        ubnand_(a, -1 - b)
-      else
-        -1 - ubor_(-1 - a, -1 - b)
-
-  // bitwise 'or' for arbitrary precision integers
-  function
-    bor : (int, int) => int
-    bor(0, b) = b
-    bor(a, 0) = a
-    bor(a : int, b : int) : int =
-      if (a >= 0 && b >= 0)
-        ubor_(a, b)
-      elif (b >= 0)
-        -1 - ubnand_(-1 - a, b)
-      elif (a >= 0)
-        -1 - ubnand_(-1 - b, a)
-      else
-        -1 - uband_(-1 - a, -1 - b)
-
-  // bitwise 'xor' for arbitrary precision integers
-  function
-    bxor : (int, int) => int
-    bxor(0, b) = b
-    bxor(a, 0) = a
-    bxor(a, b) =
-      if (a >= 0 && b >= 0)
-        ubxor_(a, b)
-      elif (b >= 0)
-        -1 - ubxor_(-1 - a, b)
-      elif (a >= 0)
-        -1 - ubxor_(a, -1 - b)
-      else
-        ubxor_(-1 - a, -1 - b)
-
-  // bitwise 'not' for arbitrary precision integers
-  function bnot(a : int) = bxor(a, -1)
-
-  // Bitwise 'and' for non-negative integers
-  function uband(a : int, b : int) : int =
-    require(a >= 0 && b >= 0, "uband is only defined for non-negative integers")
-    switch((a, b))
-      (0, _) => 0
-      (_, 0) => 0
-      _      => uband__(a, b, 1, 0)
-
-  private function uband_(a, b) = uband__(a, b, 1, 0)
-
-  private function
-    uband__(0, b, val, acc) = acc
-    uband__(a, 0, val, acc) = acc
-    uband__(a, b, val, acc) =
-      switch (a mod 2 + b mod 2)
-        2 => uband__(a / 2, b / 2, val * 2, acc + val)
-        _ => uband__(a / 2, b / 2, val * 2, acc)
-
-  // Bitwise 'or' for non-negative integers
-  function ubor(a, b) =
-    require(a >= 0 && b >= 0, "ubor is only defined for non-negative integers")
-    switch((a, b))
-      (0, _) => b
-      (_, 0) => a
-      _      => ubor__(a, b, 1, 0)
-
-  private function ubor_(a, b) = ubor__(a, b, 1, 0)
-
-  private function
-    ubor__(0, 0, val, acc) = acc
-    ubor__(a, b, val, acc) =
-      switch (a mod 2 + b mod 2)
-        0 => ubor__(a / 2, b / 2, val * 2, acc)
-        _ => ubor__(a / 2, b / 2, val * 2, acc + val)
-
-  //Bitwise 'xor' for non-negative integers
-  function
-    ubxor : (int, int) => int
-    ubxor(0, b) = b
-    ubxor(a, 0) = a
-    ubxor(a, b) =
-      require(a >= 0 && b >= 0, "ubxor is only defined for non-negative integers")
-      ubxor__(a, b, 1, 0)
-
-  private function ubxor_(a, b) = ubxor__(a, b, 1, 0)
-
-  private function
-    ubxor__(0, 0, val, acc) = acc
-    ubxor__(a, b, val, acc) =
-      switch(a mod 2 + b mod 2)
-        1 => ubxor__(a / 2, b / 2, val * 2, acc + val)
-        _ => ubxor__(a / 2, b / 2, val * 2, acc)
-
-  private function ubnand_(a, b) = ubnand__(a, b, 1, 0)
-
-  private function
-    ubnand__(0, b, val, acc) = acc
-    ubnand__(a, b, val, acc) =
-      switch((a mod 2, b mod 2))
-        (1, 0) => ubnand__(a / 2, b / 2, val * 2, acc + val)
-        _      => ubnand__(a / 2, b / 2, val * 2, acc)

rebar.config

@@ -14,7 +14,7 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "7.0.1"},
+{relx, [{release, {aesophia, "8.0.0"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

src/aeso_ast_infer_types.erl

@@ -540,6 +540,8 @@ global_env() ->
     TTL       = {qid, Ann, ["Chain", "ttl"]},
     Pointee   = {qid, Ann, ["AENS", "pointee"]},
     AENSName  = {qid, Ann, ["AENS", "name"]},
+    PointeeV2 = {qid, Ann, ["AENSv2", "pointee"]},
+    AENSNameV2 = {qid, Ann, ["AENSv2", "name"]},
     Fr        = {qid, Ann, ["MCL_BLS12_381", "fr"]},
     Fp        = {qid, Ann, ["MCL_BLS12_381", "fp"]},
     Fp2       = {tuple_t, Ann, [Fp, Fp]},
@@ -675,14 +677,7 @@ global_env() ->
 
     AENSScope = #scope
         { funs = MkDefs(
-                     [{"resolve",  Fun([String, String], option_t(Ann, A))},
-                      {"preclaim", SignFun([Address, Hash], Unit)},
-                      {"claim",    SignFun([Address, String, Int, Int], Unit)},
-                      {"transfer", SignFun([Address, Address, String], Unit)},
-                      {"revoke",   SignFun([Address, String], Unit)},
-                      {"update",   SignFun([Address, String, Option(TTL), Option(Int), Option(Map(String, Pointee))], Unit)},
-                      {"lookup",   Fun([String], option_t(Ann, AENSName))},
-                      %% AENS pointee constructors
+                     [%% AENS pointee constructors
                       {"AccountPt",  Fun1(Address, Pointee)},
                       {"OraclePt",   Fun1(Address, Pointee)},
                       {"ContractPt", Fun1(Address, Pointee)},
@@ -692,6 +687,26 @@ global_env() ->
                      ])
         , types = MkDefs([{"pointee", 0}, {"name", 0}]) },
 
+    AENSv2Scope = #scope
+        { funs = MkDefs(
+                     [{"resolve",  Fun([String, String], option_t(Ann, A))},
+                      {"preclaim", SignFun([Address, Hash], Unit)},
+                      {"claim",    SignFun([Address, String, Int, Int], Unit)},
+                      {"transfer", SignFun([Address, Address, String], Unit)},
+                      {"revoke",   SignFun([Address, String], Unit)},
+                      {"update",   SignFun([Address, String, Option(TTL), Option(Int), Option(Map(String, PointeeV2))], Unit)},
+                      {"lookup",   Fun([String], option_t(Ann, AENSNameV2))},
+                      %% AENS pointee constructors v2
+                      {"AccountPt",  Fun1(Address, PointeeV2)},
+                      {"OraclePt",   Fun1(Address, PointeeV2)},
+                      {"ContractPt", Fun1(Address, PointeeV2)},
+                      {"ChannelPt",  Fun1(Address, PointeeV2)},
+                      {"DataPt",     Fun1(String,  PointeeV2)},
+                      %% Name object constructor v2
+                      {"Name", Fun([Address, TTL, Map(String, PointeeV2)], AENSNameV2)}
+                     ])
+        , types = MkDefs([{"pointee", 0}, {"name", 0}]) },
+
     MapScope = #scope
         { funs = MkDefs(
                      [{"from_list",      Fun1(List(Pair(K, V)), Map(K, V))},
@@ -711,7 +726,8 @@ global_env() ->
                       {"ecrecover_secp256k1",  Fun([Hash, Bytes(65)], Option(Bytes(20)))},
                       {"sha3",     Fun1(A, Hash)},
                       {"sha256",   Fun1(A, Hash)},
-                      {"blake2b",  Fun1(A, Hash)}]) },
+                      {"blake2b",  Fun1(A, Hash)},
+                      {"poseidon", Fun([Int, Int], Int)}]) },
 
     %% Fancy BLS12-381 crypto operations
     MCL_BLS12_381_Scope = #scope
@@ -796,14 +812,16 @@ global_env() ->
                    ]) },
 
     %% Conversion
-    IntScope     = #scope{ funs = MkDefs([{"to_str", Fun1(Int,     String)}]) },
+    IntScope     = #scope{ funs = MkDefs([{"to_str", Fun1(Int, String)},
+                                          {"mulmod", Fun([Int, Int, Int], Int)}]) },
+
     AddressScope = #scope{ funs = MkDefs([{"to_str", Fun1(Address, String)},
+                                          {"to_bytes", Fun1(Address, Bytes(32))},
                                           {"to_contract", FunC(address_to_contract, [Address], A)},
                                           {"is_oracle", Fun1(Address, Bool)},
                                           {"is_contract", Fun1(Address, Bool)},
                                           {"is_payable", Fun1(Address, Bool)}]) },
 
-
     #env{ scopes =
             #{ []           => TopScope
              , ["Chain"]    => ChainScope
@@ -811,6 +829,7 @@ global_env() ->
              , ["Call"]     => CallScope
              , ["Oracle"]   => OracleScope
              , ["AENS"]     => AENSScope
+             , ["AENSv2"]   => AENSv2Scope
              , ["Map"]      => MapScope
              , ["Auth"]     => AuthScope
              , ["Crypto"]   => CryptoScope
@@ -1880,7 +1899,7 @@ infer_expr(Env, {app, Ann, Fun, Args0} = App) ->
             unify(Env, FunType, {fun_t, [], NamedArgsVar, ArgTypes, GeneralResultType}, When),
             when_warning(warn_negative_spend, fun() -> warn_potential_negative_spend(Ann, NewFun1, NewArgs) end),
             [ add_constraint({aens_resolve_type, GeneralResultType})
-              || element(3, FunName) =:= ["AENS", "resolve"] ],
+              || element(3, FunName) =:= ["AENSv2", "resolve"] ],
             [ add_constraint({oracle_type, Ann, OType})
               || OType <- [get_oracle_type(FunName, ArgTypes, GeneralResultType)],
                  OType =/= false ],
@@ -2167,6 +2186,11 @@ infer_infix({IntOp, As})
        IntOp == '^';    IntOp == 'mod' ->
     Int = {id, As, "int"},
     {fun_t, As, [], [Int, Int], Int};
+infer_infix({BitOp, As})
+  when BitOp == 'band'; BitOp == 'bor'; BitOp == 'bxor';
+       BitOp == '<<';   BitOp == '>>' ->
+    Int = {id, As, "int"},
+    {fun_t, As, [], [Int, Int], Int};
 infer_infix({RelOp, As})
   when RelOp == '=='; RelOp == '!=';
        RelOp == '<';  RelOp == '>';
@@ -2194,6 +2218,9 @@ infer_infix({'|>', As}) ->
 infer_prefix({'!',As}) ->
     Bool = {id, As, "bool"},
     {fun_t, As, [], [Bool], Bool};
+infer_prefix({BitOp,As}) when BitOp =:= 'bnot' ->
+    Int = {id, As, "int"},
+    {fun_t, As, [], [Int], Int};
 infer_prefix({IntOp,As}) when IntOp =:= '-' ->
     Int = {id, As, "int"},
     {fun_t, As, [], [Int], Int}.
@@ -3691,7 +3718,7 @@ mk_error({higher_order_entrypoint, Ann, {id, _, Name}, Thing}) ->
                         [ThingS, Name, Bad]),
     mk_t_err(pos(Ann), Msg);
 mk_error({invalid_aens_resolve_type, Ann, T}) ->
-    Msg = io_lib:format("Invalid return type of `AENS.resolve`:\n"
+    Msg = io_lib:format("Invalid return type of `AENSv2.resolve`:\n"
                         "~s`\n"
                         "It must be a `string` or a pubkey type (`address`, `oracle`, etc)",
                         [pp_type("  `", T)]),

src/aeso_ast_to_fcode.erl

@@ -32,12 +32,13 @@
 
 -type op() :: '+' | '-' | '*' | '/' | mod | '^' | '++' | '::' |
               '<' | '>' | '=<' | '>=' | '==' | '!=' | '!' |
+              'band' | 'bor' | 'bxor' | 'bnot' | '<<' | '>>' |
               map_get | map_get_d | map_set | map_from_list | map_to_list |
               map_delete | map_member | map_size | string_length |
               string_concat | bits_set | bits_clear | bits_test | bits_sum |
               bits_intersection | bits_union | bits_difference |
               contract_to_address | address_to_contract | crypto_verify_sig | crypto_verify_sig_secp256k1 |
-              crypto_sha3 | crypto_sha256 | crypto_blake2b |
+              crypto_sha3 | crypto_sha256 | crypto_blake2b | crypto_poseidon |
               crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1 |
               mcl_bls12_381_g1_neg | mcl_bls12_381_g1_norm | mcl_bls12_381_g1_valid |
               mcl_bls12_381_g1_is_zero | mcl_bls12_381_g1_add | mcl_bls12_381_g1_mul |
@@ -214,6 +215,12 @@ init_env(Options) ->
                       ["AENS", "ContractPt"] => #con_tag{ tag = 2, arities = [1, 1, 1, 1] },
                       ["AENS", "ChannelPt"]  => #con_tag{ tag = 3, arities = [1, 1, 1, 1] },
                       ["AENS", "Name"]       => #con_tag{ tag = 0, arities = [3] },
+                      ["AENSv2", "AccountPt"]  => #con_tag{ tag = 0, arities = [1, 1, 1, 1, 1] },
+                      ["AENSv2", "OraclePt"]   => #con_tag{ tag = 1, arities = [1, 1, 1, 1, 1] },
+                      ["AENSv2", "ContractPt"] => #con_tag{ tag = 2, arities = [1, 1, 1, 1, 1] },
+                      ["AENSv2", "ChannelPt"]  => #con_tag{ tag = 3, arities = [1, 1, 1, 1, 1] },
+                      ["AENSv2", "DataPt"]     => #con_tag{ tag = 4, arities = [1, 1, 1, 1, 1] },
+                      ["AENSv2", "Name"]       => #con_tag{ tag = 0, arities = [3] },
                       ["Chain", "GAMetaTx"]               => #con_tag{ tag = 0, arities = [2] },
                       ["Chain", "PayingForTx"]            => #con_tag{ tag = 0, arities = [2] },
                       ["Chain", "SpendTx"]                => #con_tag{ tag = 0, arities = ChainTxArities },
@@ -245,8 +252,11 @@ init_env(Options) ->
 
 -spec builtins() -> builtins().
 builtins() ->
-    MkName = fun(NS, Fun) ->
-                list_to_atom(string:to_lower(string:join(NS ++ [Fun], "_")))
+    MkName = fun
+               (["AENSv2"], Fun) ->
+                 list_to_atom(string:to_lower("AENS_" ++ Fun));
+               (NS, Fun) ->
+                 list_to_atom(string:to_lower(string:join(NS ++ [Fun], "_")))
              end,
     Scopes = [{[],           [{"abort", 1}, {"require", 2}, {"exit", 1}]},
               {["Chain"],    [{"spend", 2}, {"balance", 1}, {"block_hash", 1}, {"coinbase", none},
@@ -258,13 +268,13 @@ builtins() ->
               {["Oracle"],   [{"register", 4}, {"expiry", 1}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
                               {"respond", 4}, {"extend", 3}, {"get_answer", 2},
                               {"check", 1}, {"check_query", 2}]},
-              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 5}, {"transfer", 4},
+              {["AENSv2"],   [{"resolve", 2}, {"preclaim", 3}, {"claim", 5}, {"transfer", 4},
                               {"revoke", 3}, {"update", 6}, {"lookup", 1}]},
               {["Map"],      [{"from_list", 1}, {"to_list", 1}, {"lookup", 2},
                               {"lookup_default", 3}, {"delete", 2}, {"member", 2}, {"size", 1}]},
               {["Crypto"],   [{"verify_sig", 3}, {"verify_sig_secp256k1", 3},
                               {"ecverify_secp256k1", 3}, {"ecrecover_secp256k1", 2},
-                              {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
+                              {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}, {"poseidon", 2}]},
               {["MCL_BLS12_381"], [{"g1_neg", 1}, {"g1_norm", 1}, {"g1_valid", 1}, {"g1_is_zero", 1}, {"g1_add", 2}, {"g1_mul", 2},
                                    {"g2_neg", 1}, {"g2_norm", 1}, {"g2_valid", 1}, {"g2_is_zero", 1}, {"g2_add", 2}, {"g2_mul", 2},
                                    {"gt_inv", 1}, {"gt_add", 2}, {"gt_mul", 2}, {"gt_pow", 2}, {"gt_is_one", 1},
@@ -277,8 +287,9 @@ builtins() ->
               {["Bits"],     [{"set", 2}, {"clear", 2}, {"test", 2}, {"sum", 1}, {"intersection", 2},
                               {"union", 2}, {"difference", 2}, {"none", none}, {"all", none}]},
               {["Bytes"],    [{"to_int", 1}, {"to_str", 1}, {"concat", 2}, {"split", 1}]},
-              {["Int"],      [{"to_str", 1}]},
-              {["Address"],  [{"to_str", 1}, {"to_contract", 1}, {"is_oracle", 1}, {"is_contract", 1}, {"is_payable", 1}]}
+              {["Int"],      [{"to_str", 1}, {"mulmod", 2}]},
+              {["Address"],  [{"to_str", 1}, {"to_bytes", 1}, {"to_contract", 1},
+                              {"is_oracle", 1}, {"is_contract", 1}, {"is_payable", 1}]}
              ],
     maps:from_list([ {NS ++ [Fun], {MkName(NS, Fun), Arity}}
                      || {NS, Funs} <- Scopes,
@@ -313,11 +324,13 @@ init_type_env() ->
        ["Chain", "ttl"]    => ?type({variant, [[integer], [integer]]}),
        ["AENS", "pointee"] => ?type({variant, [[address], [address], [address], [address]]}),
        ["AENS", "name"]    => ?type({variant, [[address, {variant, [[integer], [integer]]}, {map, string, {variant, [[address], [address], [address], [address]]}}]]}),
+       ["AENSv2", "pointee"] => ?type({variant, [[address], [address], [address], [address], [string]]}),
+       ["AENSv2", "name"]    => ?type({variant, [[address, {variant, [[integer], [integer]]}, {map, string, {variant, [[address], [address], [address], [address], [string]]}}]]}),
        ["Chain", "ga_meta_tx"]    => ?type({variant, [[address, integer]]}),
        ["Chain", "paying_for_tx"] => ?type({variant, [[address, integer]]}),
        ["Chain", "base_tx"]       => ?type(BaseTx),
-       ["MCL_BLS12_381", "fr"]  => ?type({bytes, 32}),
-       ["MCL_BLS12_381", "fp"]  => ?type({bytes, 48})
+       ["MCL_BLS12_381", "fr"] => ?type({bytes, 32}),
+       ["MCL_BLS12_381", "fp"] => ?type({bytes, 48})
      }.
 
 is_no_code(Env) ->
@@ -694,8 +707,9 @@ expr_to_fcode(Env, Type, {app, Ann, {Op, _}, [A, B]}) when is_atom(Op) ->
     end;
 expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A]}) when is_atom(Op) ->
     case Op of
-        '-' -> {op, '-', [{lit, {int, 0}}, expr_to_fcode(Env, A)]};
-        '!' -> {op, '!', [expr_to_fcode(Env, A)]}
+        '-'    -> {op, '-', [{lit, {int, 0}}, expr_to_fcode(Env, A)]};
+        'bnot' -> {op, 'bnot', [expr_to_fcode(Env, A)]};
+        '!'    -> {op, '!', [expr_to_fcode(Env, A)]}
     end;
 
 %% Function calls
@@ -1086,9 +1100,9 @@ op_builtins() ->
      stringinternal_sha3, stringinternal_sha256, stringinternal_blake2b,
      char_to_int, char_from_int, stringinternal_to_lower, stringinternal_to_upper,
      bits_set, bits_clear, bits_test, bits_sum, bits_intersection, bits_union,
-     bits_difference, int_to_str, address_to_str, crypto_verify_sig,
+     bits_difference, int_to_str, int_mulmod, address_to_str, address_to_bytes, crypto_verify_sig,
      address_to_contract,
-     crypto_verify_sig_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b,
+     crypto_verify_sig_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b, crypto_poseidon,
      crypto_ecverify_secp256k1, crypto_ecrecover_secp256k1,
      mcl_bls12_381_g1_neg, mcl_bls12_381_g1_norm, mcl_bls12_381_g1_valid,
      mcl_bls12_381_g1_is_zero, mcl_bls12_381_g1_add, mcl_bls12_381_g1_mul,

src/aeso_fcode_to_fate.erl

@@ -682,6 +682,12 @@ op_to_scode('>=')              -> aeb_fate_ops:egt(?a, ?a, ?a);
 op_to_scode('==')              -> aeb_fate_ops:eq(?a, ?a, ?a);
 op_to_scode('!=')              -> aeb_fate_ops:neq(?a, ?a, ?a);
 op_to_scode('!')               -> aeb_fate_ops:not_op(?a, ?a);
+op_to_scode('bnot')            -> aeb_fate_ops:bin_not(?a, ?a);
+op_to_scode('band')            -> aeb_fate_ops:bin_and(?a, ?a, ?a);
+op_to_scode('bor')             -> aeb_fate_ops:bin_or(?a, ?a, ?a);
+op_to_scode('bxor')            -> aeb_fate_ops:bin_xor(?a, ?a, ?a);
+op_to_scode('<<')              -> aeb_fate_ops:bin_sl(?a, ?a, ?a);
+op_to_scode('>>')              -> aeb_fate_ops:bin_sr(?a, ?a, ?a);
 op_to_scode(map_get)           -> aeb_fate_ops:map_lookup(?a, ?a, ?a);
 op_to_scode(map_get_d)         -> aeb_fate_ops:map_lookup(?a, ?a, ?a, ?a);
 op_to_scode(map_set)           -> aeb_fate_ops:map_update(?a, ?a, ?a, ?a);
@@ -706,7 +712,9 @@ op_to_scode(bits_intersection) -> aeb_fate_ops:bits_and(?a, ?a, ?a);
 op_to_scode(bits_union)        -> aeb_fate_ops:bits_or(?a, ?a, ?a);
 op_to_scode(bits_difference)   -> aeb_fate_ops:bits_diff(?a, ?a, ?a);
 op_to_scode(address_to_str)    -> aeb_fate_ops:addr_to_str(?a, ?a);
+op_to_scode(address_to_bytes)  -> aeb_fate_ops:addr_to_bytes(?a, ?a);
 op_to_scode(int_to_str)        -> aeb_fate_ops:int_to_str(?a, ?a);
+op_to_scode(int_mulmod)        -> aeb_fate_ops:mulmod(?a, ?a, ?a, ?a);
 op_to_scode(contract_to_address)         -> aeb_fate_ops:contract_to_address(?a, ?a);
 op_to_scode(address_to_contract)         -> aeb_fate_ops:address_to_contract(?a, ?a);
 op_to_scode(crypto_verify_sig)           -> aeb_fate_ops:verify_sig(?a, ?a, ?a, ?a);
@@ -716,6 +724,7 @@ op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a,
 op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(crypto_poseidon)             -> aeb_fate_ops:poseidon(?a, ?a, ?a);
 op_to_scode(stringinternal_sha3)         -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(stringinternal_sha256)       -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(stringinternal_blake2b)      -> aeb_fate_ops:blake2b(?a, ?a);
@@ -913,6 +922,13 @@ attributes(I) ->
         {'DIV', A, B, C}                      -> Pure(A, [B, C]);
         {'MOD', A, B, C}                      -> Pure(A, [B, C]);
         {'POW', A, B, C}                      -> Pure(A, [B, C]);
+        {'MULMOD', A, B, C, D}                -> Pure(A, [B, C, D]);
+        {'BAND', A, B, C}                     -> Pure(A, [B, C]);
+        {'BOR', A, B, C}                      -> Pure(A, [B, C]);
+        {'BXOR', A, B, C}                     -> Pure(A, [B, C]);
+        {'BNOT', A, B}                        -> Pure(A, [B]);
+        {'BSL', A, B, C}                      -> Pure(A, [B, C]);
+        {'BSR', A, B, C}                      -> Pure(A, [B, C]);
         {'LT', A, B, C}                       -> Pure(A, [B, C]);
         {'GT', A, B, C}                       -> Pure(A, [B, C]);
         {'EQ', A, B, C}                       -> Pure(A, [B, C]);
@@ -965,12 +981,14 @@ attributes(I) ->
         {'SHA3', A, B}                        -> Pure(A, [B]);
         {'SHA256', A, B}                      -> Pure(A, [B]);
         {'BLAKE2B', A, B}                     -> Pure(A, [B]);
+        {'POSEIDON', A, B, C}                 -> Pure(A, [B, C]);
         {'VERIFY_SIG', A, B, C, D}            -> Pure(A, [B, C, D]);
         {'VERIFY_SIG_SECP256K1', A, B, C, D}  -> Pure(A, [B, C, D]);
         {'ECVERIFY_SECP256K1', A, B, C, D}    -> Pure(A, [B, C, D]);
         {'ECRECOVER_SECP256K1', A, B, C}      -> Pure(A, [B, C]);
         {'CONTRACT_TO_ADDRESS', A, B}         -> Pure(A, [B]);
         {'ADDRESS_TO_CONTRACT', A, B}         -> Pure(A, [B]);
+        {'ADDRESS_TO_BYTES', A, B}            -> Pure(A, [B]);
         {'AUTH_TX_HASH', A}                   -> Pure(A, []);
         {'AUTH_TX', A}                        -> Pure(A, []);
         {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);

src/aeso_parser.erl

@@ -333,14 +333,19 @@ expr100() ->
 
 expr150() -> infixl(expr200(), binop('|>')).
 expr200() -> infixr(expr300(), binop('||')).
-expr300() -> infixr(expr400(), binop('&&')).
+expr300() -> infixr(expr325(), binop('&&')).
+expr325() -> infixl(expr350(), binop('bor')).
+expr350() -> infixl(expr375(), binop('bxor')).
+expr375() -> infixl(expr400(), binop('band')).
 expr400() -> infix(expr500(),  binop(['<', '>', '=<', '>=', '==', '!='])).
-expr500() -> infixr(expr600(), binop(['::', '++'])).
+expr500() -> infixr(expr550(), binop(['::', '++'])).
+expr550() -> infixl(expr600(), binop(['<<', '>>'])).
 expr600() -> infixl(expr650(), binop(['+', '-'])).
 expr650() -> ?RULE(many(token('-')), expr700(), prefixes(_1, _2)).
 expr700() -> infixl(expr750(), binop(['*', '/', mod])).
 expr750() -> infixl(expr800(), binop(['^'])).
-expr800() -> ?RULE(many(token('!')), expr900(), prefixes(_1, _2)).
+expr800() -> ?RULE(many(token('!')), expr850(), prefixes(_1, _2)).
+expr850() -> ?RULE(many(token('bnot')), expr900(), prefixes(_1, _2)).
 expr900() -> ?RULE(exprAtom(), many(elim()), elim(_1, _2)).
 
 exprAtom() ->

src/aeso_pretty.erl

@@ -436,15 +436,20 @@ bin_prec('=')    -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('@')    -> {  0,   0,   0};  %% Only in error messages
 bin_prec('|>')   -> {150, 150, 200};
 bin_prec('||')   -> {200, 300, 200};
-bin_prec('&&')   -> {300, 400, 300};
+bin_prec('&&')   -> {300, 325, 300};
+bin_prec('bor')  -> {325, 350, 325};
+bin_prec('bxor') -> {350, 375, 350};
+bin_prec('band') -> {375, 400, 375};
 bin_prec('<')    -> {400, 500, 500};
 bin_prec('>')    -> {400, 500, 500};
 bin_prec('=<')   -> {400, 500, 500};
 bin_prec('>=')   -> {400, 500, 500};
 bin_prec('==')   -> {400, 500, 500};
 bin_prec('!=')   -> {400, 500, 500};
-bin_prec('++')   -> {500, 600, 500};
-bin_prec('::')   -> {500, 600, 500};
+bin_prec('++')   -> {500, 550, 500};
+bin_prec('::')   -> {500, 550, 500};
+bin_prec('<<')   -> {550, 600, 550};
+bin_prec('>>')   -> {550, 600, 550};
 bin_prec('+')    -> {600, 600, 650};
 bin_prec('-')    -> {600, 600, 650};
 bin_prec('*')    -> {700, 700, 750};
@@ -454,7 +459,8 @@ bin_prec('^')    -> {750, 750, 800}.
 
 -spec un_prec(aeso_syntax:un_op()) -> {integer(), integer()}.
 un_prec('-')    -> {650, 650};
-un_prec('!')    -> {800, 800}.
+un_prec('!')    -> {800, 800};
+un_prec('bnot') -> {850, 850}.
 
 equals(Ann, A, B) ->
     {app, [{format, infix} | Ann], {'=', Ann}, [A, B]}.

src/aeso_scan.erl

@@ -45,7 +45,7 @@ lexer() ->
 
     Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
                 "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
-                "interface", "main", "using", "as", "for", "hiding"
+                "interface", "main", "using", "as", "for", "hiding", "band", "bor", "bxor", "bnot"
                ],
     KW = string:join(Keywords, "|"),
 

src/aeso_syntax.erl

@@ -106,8 +106,8 @@
 
 -type bin_op() :: '+' | '-' | '*' | '/' | mod | '^'
                 | '++' | '::' | '<' | '>' | '=<' | '>=' | '==' | '!='
-                | '||' | '&&' | '..' | '|>'.
--type un_op() :: '-' | '!'.
+                | '||' | '&&' | '..' | 'band' | 'bor' | 'bxor' | '>>' | '<<' | '|>'.
+-type un_op() :: '-' | '!' | 'bnot'.
 
 -type expr()
     :: {lam, ann(), [arg()], expr()}

src/aeso_vm_decode.erl

@@ -88,7 +88,7 @@ from_fate_builtin(QType, Val) ->
 
         {["AENS", "name"], {variant, [3], 0, {Addr, TTL, Ptrs}}} ->
             App(["AENS","Name"], [Chk(Adr, Addr), Chk(Qid(["Chain", "ttl"]), TTL),
-                              Chk(Map(Str, Qid(["AENS", "pointee"])), Ptrs)]);
+                                  Chk(Map(Str, Qid(["AENS", "pointee"])), Ptrs)]);
 
         {["AENS", "pointee"], {variant, [1, 1, 1, 1], 0, {Addr}}} ->
             App(["AENS","AccountPt"], [Chk(Adr, Addr)]);
@@ -99,6 +99,21 @@ from_fate_builtin(QType, Val) ->
         {["AENS", "pointee"], {variant, [1, 1, 1, 1], 3, {Addr}}} ->
             App(["AENS","ChannelPt"], [Chk(Adr, Addr)]);
 
+        {["AENSv2", "name"], {variant, [3], 0, {Addr, TTL, Ptrs}}} ->
+            App(["AENSv2","Name"], [Chk(Adr, Addr), Chk(Qid(["Chain", "ttl"]), TTL),
+                                    Chk(Map(Str, Qid(["AENSv2", "pointee"])), Ptrs)]);
+
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 0, {Val}}} ->
+            App(["AENSv2","AccountPt"], [Chk(Adr, Val)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 1, {Val}}} ->
+            App(["AENSv2","OraclePt"], [Chk(Adr, Val)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 2, {Val}}} ->
+            App(["AENSv2","ContractPt"], [Chk(Adr, Val)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 3, {Val}}} ->
+            App(["AENSv2","ChannelPt"], [Chk(Adr, Val)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 4, {Val}}} ->
+            App(["AENSv2","DataPt"], [Chk(Str, Val)]);
+
         {["Chain", "ga_meta_tx"], {variant, [2], 0, {Addr, X}}} ->
             App(["Chain","GAMetaTx"], [Chk(Adr, Addr), Chk(Int, X)]);
 

src/aesophia.app.src

@@ -1,6 +1,6 @@
 {application, aesophia,
  [{description, "Compiler for Aeternity Sophia language"},
-  {vsn, "7.0.1"},
+  {vsn, "8.0.0"},
   {registered, []},
   {applications,
    [kernel,

test/aeso_compiler_tests.erl

@@ -218,6 +218,7 @@ compilable_contracts() ->
      "unapplied_contract_call",
      "unapplied_named_arg_builtin",
      "resolve_field_constraint_by_arity",
+     "ceres",
      "test" % Custom general-purpose test file. Keep it last on the list.
     ].
 
@@ -1095,19 +1096,19 @@ failing_contracts() ->
                   ])
     , ?TYPE_ERROR(polymorphic_aens_resolve,
                   [<<?Pos(4,5)
-                     "Invalid return type of `AENS.resolve`:\n"
+                     "Invalid return type of `AENSv2.resolve`:\n"
                      "  `'a`\n"
                      "It must be a `string` or a pubkey type (`address`, `oracle`, etc)">>
                   ])
     , ?TYPE_ERROR(bad_aens_resolve,
                   [<<?Pos(6,5)
-                     "Invalid return type of `AENS.resolve`:\n"
+                     "Invalid return type of `AENSv2.resolve`:\n"
                      "  `list(int)`\n"
                      "It must be a `string` or a pubkey type (`address`, `oracle`, etc)">>
                   ])
     , ?TYPE_ERROR(bad_aens_resolve_using,
                   [<<?Pos(7,5)
-                     "Invalid return type of `AENS.resolve`:\n"
+                     "Invalid return type of `AENSv2.resolve`:\n"
                      "  `list(int)`\n"
                      "It must be a `string` or a pubkey type (`address`, `oracle`, etc)">>
                   ])

test/aeso_parser_tests.erl

@@ -53,7 +53,7 @@ simple_contracts_test_() ->
             %% associativity
             [ RightAssoc(Op) || Op <- ["||", "&&", "::", "++"] ],
             [ NonAssoc(Op)   || Op <- ["==", "!=", "<", ">", "=<", ">="] ],
-            [ LeftAssoc(Op)  || Op <- ["+", "-", "*", "/", "mod"] ],
+            [ LeftAssoc(Op)  || Op <- ["+", "-", "*", "/", "mod", "band", "bor", "bxor", "<<", ">>"] ],
 
             %% precedence
             [ Stronger(Op2, Op1) || [T1 , T2 | _] <- tails(Tiers), Op1 <- T1, Op2 <- T2 ],

test/aeso_scan_tests.erl

@@ -39,7 +39,8 @@ all_tokens() ->
     %% Symbols
     lists:map(Lit, [',', '.', ';', '|', ':', '(', ')', '[', ']', '{', '}']) ++
     %% Operators
-    lists:map(Lit, ['=', '==', '!=', '>', '<', '>=', '=<', '-', '+', '++', '*', '/', mod, ':', '::', '->', '=>', '||', '&&', '!']) ++
+    lists:map(Lit, ['=', '==', '!=', '>', '<', '>=', '=<', '-', '+', '++', '*', '/', mod,
+                    ':', '::', '->', '=>', '||', '&&', '!', 'band', 'bor', 'bxor', 'bnot' ,'<<', '>>']) ++
     %% Keywords
     lists:map(Lit, [contract, type, 'let', switch]) ++
     %% Comment token (not an actual token), just for tests

test/contracts/aens.aes

@@ -6,77 +6,77 @@ main contract AENSTest =
   // Name resolution
 
   stateful entrypoint resolve_word(name : string, key : string) : option(address) =
-    AENS.resolve(name, key)
+    AENSv2.resolve(name, key)
 
   stateful entrypoint resolve_string(name : string, key : string) : option(string) =
-    AENS.resolve(name, key)
+    AENSv2.resolve(name, key)
 
   stateful entrypoint resolve_contract(name : string, key : string) : option(C) =
-    AENS.resolve(name, key)
+    AENSv2.resolve(name, key)
 
   stateful entrypoint resolve_oracle(name : string, key : string) : option(oracle(int, int)) =
-    AENS.resolve(name, key)
+    AENSv2.resolve(name, key)
 
   stateful entrypoint resolve_oracle_query(name : string, key : string) : option(oracle_query(int, int)) =
-    AENS.resolve(name, key)
+    AENSv2.resolve(name, key)
 
   // Transactions
 
   stateful entrypoint preclaim(addr  : address,     // Claim on behalf of this account (can be Contract.address)
                                chash : hash) : unit = // Commitment hash
-    AENS.preclaim(addr, chash)
+    AENSv2.preclaim(addr, chash)
 
   stateful entrypoint signedPreclaim(addr  : address, // Claim on behalf of this account (can be Contract.address)
                                    chash : hash,             // Commitment hash
                                    sign  : signature) : unit = // Signed by addr (if not Contract.address)
-    AENS.preclaim(addr, chash, signature = sign)
+    AENSv2.preclaim(addr, chash, signature = sign)
 
   stateful entrypoint claim(addr : address,
                           name : string,
                           salt : int,
                           name_fee : int) : unit =
-    AENS.claim(addr, name, salt, name_fee)
+    AENSv2.claim(addr, name, salt, name_fee)
 
   stateful entrypoint signedClaim(addr : address,
                                 name : string,
                                 salt : int,
                                 name_fee : int,
                                 sign : signature) : unit =
-    AENS.claim(addr, name, salt, name_fee, signature = sign)
+    AENSv2.claim(addr, name, salt, name_fee, signature = sign)
 
 
   stateful entrypoint update(owner      : address,
                              name       : string,
                              ttl        : option(Chain.ttl),
                              client_ttl : option(int),
-                             pointers   : option(map(string, AENS.pointee))) : unit =
-    AENS.update(owner, name, ttl, client_ttl, pointers)
+                             pointers   : option(map(string, AENSv2.pointee))) : unit =
+    AENSv2.update(owner, name, ttl, client_ttl, pointers)
 
   stateful entrypoint signedUpdate(owner      : address,
                                    name       : string,
                                    ttl        : option(Chain.ttl),
                                    client_ttl : option(int),
-                                   pointers   : option(map(string, AENS.pointee)),
+                                   pointers   : option(map(string, AENSv2.pointee)),
                                    sign       : signature) : unit =
-    AENS.update(owner, name, ttl, client_ttl, pointers, signature = sign)
+    AENSv2.update(owner, name, ttl, client_ttl, pointers, signature = sign)
 
 
   stateful entrypoint transfer(owner     : address,
                              new_owner : address,
                              name      : string) : unit =
-    AENS.transfer(owner, new_owner, name)
+    AENSv2.transfer(owner, new_owner, name)
 
   stateful entrypoint signedTransfer(owner     : address,
                                      new_owner : address,
                                      name      : string,
                                      sign      : signature) : unit =
-    AENS.transfer(owner, new_owner, name, signature = sign)
+    AENSv2.transfer(owner, new_owner, name, signature = sign)
 
   stateful entrypoint revoke(owner     : address,
                            name      : string) : unit =
-    AENS.revoke(owner, name)
+    AENSv2.revoke(owner, name)
 
   stateful entrypoint signedRevoke(owner     : address,
                                    name      : string,
                                    sign      : signature) : unit =
-    AENS.revoke(owner, name, signature = sign)
+    AENSv2.revoke(owner, name, signature = sign)

test/contracts/aens_update.aes

@@ -1,17 +1,30 @@
-contract AENSUpdate =
+include "Option.aes"
+include "AENSCompat.aes"
+contract interface OldAENSContract =
+  entrypoint set : (string, string, AENS.pointee) => unit
+  entrypoint lookup : (string, string) => AENS.pointee
+
+main contract AENSUpdate =
   stateful entrypoint update_name(owner : address, name : string) =
-    let p1 : AENS.pointee = AENS.AccountPt(Call.caller)
-    let p2 : AENS.pointee = AENS.OraclePt(Call.caller)
-    let p3 : AENS.pointee = AENS.ContractPt(Call.caller)
-    let p4 : AENS.pointee = AENS.ChannelPt(Call.caller)
-    AENS.update(owner, name, None, None,
-                Some({ ["account_pubkey"] = p1, ["oracle_pubkey"] = p2,
-                       ["contract_pubkey"] = p3, ["misc"] = p4 }))
+    let p1 : AENSv2.pointee = AENSv2.AccountPt(Call.caller)
+    let p2 : AENSv2.pointee = AENSv2.OraclePt(Call.caller)
+    let p3 : AENSv2.pointee = AENSv2.ContractPt(Call.caller)
+    let p4 : AENSv2.pointee = AENSv2.ChannelPt(Call.caller)
+    let p5 : AENSv2.pointee = AENSv2.DataPt("any something will do")
+    AENSv2.update(owner, name, None, None,
+                  Some({ ["account_pubkey"] = p1, ["oracle_pubkey"] = p2,
+                         ["contract_pubkey"] = p3, ["misc"] = p4, ["data"] = p5 }))
+
+  stateful entrypoint old_interaction(c : OldAENSContract, owner : address, name : string) =
+    let p : AENS.pointee = c.lookup(name, "key1")
+    AENSv2.update(owner, name, None, None, Some({ ["key1"] = AENSCompat.pointee_to_V2(p) }))
+    switch(AENSv2.lookup(name))
+      Some(AENSv2.Name(_, _, pt_map)) =>
+        c.set(name, "key2", Option.force(AENSCompat.pointee_from_V2(pt_map["key1"])))
 
   entrypoint get_ttl(name : string) =
-    switch(AENS.lookup(name))
-     Some(AENS.Name(_, FixedTTL(ttl), _)) => ttl
+    switch(AENSv2.lookup(name))
+     Some(AENSv2.Name(_, FixedTTL(ttl), _)) => ttl
 
   entrypoint expiry(o : oracle(int, int)) : int =
     Oracle.expiry(o)
-

test/contracts/bad_aens_resolve.aes

@@ -3,7 +3,7 @@ contract BadAENSresolve =
   type t('a) = option(list('a))
 
   function fail() : t(int) =
-    AENS.resolve("foo.aet", "whatever")
+    AENSv2.resolve("foo.aet", "whatever")
 
   entrypoint main_fun() = ()
 

test/contracts/bad_aens_resolve_using.aes

@@ -1,9 +1,9 @@
 contract BadAENSresolve =
-  using AENS
+  using AENSv2
 
   type t('a) = option(list('a))
 
   function fail() : t(int) =
     resolve("foo.aet", "whatever")
 
-  entrypoint main_fun() = ()
+  entrypoint main_fun() = ()

test/contracts/ceres.aes

@@ -0,0 +1,14 @@
+contract C =
+  entrypoint test() =
+    let a : int = 23
+    let b : int = 52
+    let c = a bor b
+    let d = c bxor b
+    let e = d band b
+    let f = bnot a
+    let g = f << 2
+    let h = g >> 2
+    let i = Int.mulmod(a, b, h)
+    let j = Crypto.poseidon(i, a)
+    let k : bytes(32) = Address.to_bytes(Call.origin)
+    (a bor b band c bxor a << bnot b >> a, k)

test/contracts/polymorphic_aens_resolve.aes

@@ -1,7 +1,7 @@
 contract PolymorphicAENSresolve =
 
   function fail() : option('a) =
-    AENS.resolve("foo.aet", "whatever")
+    AENSv2.resolve("foo.aet", "whatever")
 
   entrypoint main_fun() = ()
 

test/contracts/unapplied_builtins.aes

@@ -2,10 +2,10 @@
 // Named argument builtins are:
 //    Oracle.register
 //    Oracle.respond
-//    AENS.preclaim
-//    AENS.claim
-//    AENS.transfer
-//    AENS.revoke
+//    AENSv2.preclaim
+//    AENSv2.claim
+//    AENSv2.transfer
+//    AENSv2.revoke
 //    Oracle.extend
 include "String.aes"
 contract UnappliedBuiltins =
@@ -28,7 +28,7 @@ contract UnappliedBuiltins =
   function oracle_get_answer()           = Oracle.get_answer   : (o, _) => _
   function oracle_check()                = Oracle.check        : o => _
   function oracle_check_query()          = Oracle.check_query  : (o, _) => _
-  function aens_resolve()                = AENS.resolve        : (_, _) => option(string)
+  function aens_resolve()                = AENSv2.resolve      : (_, _) => option(string)
   function map_lookup()                  = Map.lookup          : (_, m) => _
   function map_lookup_default()          = Map.lookup_default  : (_, m, _) => _
   function map_member()                  = Map.member          : (_, m) => _