Feature/node 2.0.0

.env

@@ -1,2 +1,14 @@
 # this is used by docker-compose.yml to for the node image tag
-TAG=v1.4.0
+TAG=v2.0.0
+
+
+Coordinate the developmnet of the sdks (features, release schedule, development policies)
+Coordinate with the core team to keep all the aepps working on the 3 environments 
+Maintain the aepps so they keep working
+Maintain a 2 way communication between core team and aepps team
+Operate 3 environments (mainnet, testnet, unstable) that are used by the aepps and the public
+Operate all the aepps-dev in the 3 environments + other stuff (like hackmd)
+Design and mediate the feature/user experience for developer tools with the teams 
+Keep track of the security issues and  
+
+

Jenkinsfile

@@ -12,7 +12,6 @@ pipeline {
 
   environment {
     DOCKER_COMPOSE = "docker-compose -p ${env.BUILD_TAG} -H 127.0.0.1:2376"
-    SCANNER_HOME = tool 'default-sonarqube-scanner'
   }
 
   stages {
@@ -21,12 +20,9 @@ pipeline {
           withCredentials([usernamePassword(credentialsId: 'genesis-wallet',
                                           usernameVariable: 'WALLET_PUB',
                                           passwordVariable: 'WALLET_PRIV')]) {
+          sh "${env.DOCKER_COMPOSE} pull node"
           sh "${env.DOCKER_COMPOSE} run sdk flake8"
           sh "${env.DOCKER_COMPOSE} run sdk make test"
-          // run sonar?
-          // withSonarQubeEnv('default-sonarqube-server') {
-          //   sh "${env.SCANNER_HOME}/bin/sonar-scanner -X"
-          // }
         }
       }
     }

aeternity/__init__.py

@@ -1,6 +1,6 @@
-__version__ = '1.1.2'
+__version__ = '2.0.0a1'
 
 __compatibility__ = dict(
-    from_version=">=1.0.0",
-    to_version="<2.0.0"
+    from_version=">=1.4.0",
+    to_version="<3.0.0"
 )

aeternity/__main__.py

@@ -846,7 +846,7 @@ def chain_play(height,  limit, force, wait, json_):
             limit -= 1
             if limit <= 0:
                 break
-            g = cli.get_generation_by_hash(hash=g.key_block.get("prev_key_hash"))
+            g = cli.get_generation_by_hash(hash=g.key_block.prev_key_hash)
     except Exception as e:
         print(e)
         g = None

aeternity/config.py

@@ -1,12 +1,8 @@
 import requests
-import sys
 import semver
 from collections import MutableSequence
 from . import __compatibility__
 
-# vm version specification
-# https://github.com/aeternity/protocol/blob/master/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain
-AEVM_NO_VM = 0
 # fee calculation
 GAS_PER_BYTE = 20
 BASE_GAS = 15000
@@ -17,13 +13,13 @@
 NAME_CLIENT_TTL = 60000
 DEFAULT_NAME_TTL = 500
 # default relative ttl in number of blocks  for executing transaction on the chain
-MAX_TX_TTL = sys.maxsize
+MAX_TX_TTL = 256
 DEFAULT_TX_TTL = 0
 # default fee for posting transaction
-DEFAULT_FEE = 20000
+DEFAULT_FEE = 0
 # contracts
-CONTRACT_DEFAULT_GAS = 170000
-CONTRACT_DEFAULT_GAS_PRICE = 1
+CONTRACT_DEFAULT_GAS = 100000
+CONTRACT_DEFAULT_GAS_PRICE = 1000000000
 CONTRACT_DEFAULT_DEPOSIT = 0
 CONTRACT_DEFAULT_VM_VERSION = 1
 CONTRACT_DEFAULT_AMOUNT = 0
@@ -35,8 +31,6 @@
 ORACLE_DEFAULT_TTL_VALUE = 500
 ORACLE_DEFAULT_QUERY_TTL_VALUE = 10
 ORACLE_DEFAULT_RESPONSE_TTL_VALUE = 10
-ORACLE_DEFAULT_VM_VERSION = AEVM_NO_VM
-
 
 # network id
 DEFAULT_NETWORK_ID = "ae_mainnet"

aeternity/contract.py

@@ -1,6 +1,7 @@
-from aeternity.openapi import OpenAPIClientException
+from aeternity.openapi import OpenAPIClientException, UnsupportedEpochVersion
 from aeternity import utils, config
-from aeternity.identifiers import CONTRACT_ID
+from aeternity.identifiers import CONTRACT_ID, CONTRACT_ROMA_VM, CONTRACT_ROMA_ABI, CONTRACT_MINERVA_VM, CONTRACT_MINERVA_ABI
+import semver
 
 
 class ContractError(Exception):
@@ -42,22 +43,29 @@ def tx_call(self, account, function, arg,
                 gas=config.CONTRACT_DEFAULT_GAS,
                 gas_price=config.CONTRACT_DEFAULT_GAS_PRICE,
                 fee=config.DEFAULT_FEE,
-                vm_version=config.CONTRACT_DEFAULT_VM_VERSION,
+                vm_version=None,
+                abi_version=None,
                 tx_ttl=config.DEFAULT_TX_TTL):
         """Call a sophia contract"""
 
         if not utils.is_valid_hash(self.address, prefix=CONTRACT_ID):
             raise ValueError("Missing contract id")
 
         try:
+            # retrieve the correct vm/abi version
+            vm, abi = self._get_vm_abi_versions()
+            vm_version = vm if vm_version is None else vm_version
+            abi_version = abi if abi_version is None else abi_version
             # prepare the call data
             call_data = self.encode_calldata(function, arg)
             # get the transaction builder
             txb = self.client.tx_builder
             # get the account nonce and ttl
             nonce, ttl = self.client._get_nonce_ttl(account.get_address(), tx_ttl)
             # build the transaction
-            tx = txb.tx_contract_call(account.get_address(), self.address, call_data, function, arg, amount, gas, gas_price, vm_version, fee, ttl, nonce)
+            tx = txb.tx_contract_call(account.get_address(), self.address, call_data, function, arg,
+                                      amount, gas, gas_price, abi_version,
+                                      fee, ttl, nonce)
             # sign the transaction
             tx_signed, sg, tx_hash = self.client.sign_transaction(account, tx)
             # post the transaction to the chain
@@ -76,21 +84,27 @@ def tx_create(self,
                   gas=config.CONTRACT_DEFAULT_GAS,
                   gas_price=config.CONTRACT_DEFAULT_GAS_PRICE,
                   fee=config.DEFAULT_FEE,
-                  vm_version=config.CONTRACT_DEFAULT_VM_VERSION,
+                  vm_version=None,
+                  abi_version=None,
                   tx_ttl=config.DEFAULT_TX_TTL):
         """
         Create a contract and deploy it to the chain
         :return: address
         """
         try:
+            # retrieve the correct vm/abi version
+            vm, abi = self._get_vm_abi_versions()
+            vm_version = vm if vm_version is None else vm_version
+            abi_version = abi if abi_version is None else abi_version
+            # encode the call data
             call_data = self.encode_calldata("init", init_state)
-
             # get the transaction builder
             txb = self.client.tx_builder
             # get the account nonce and ttl
             nonce, ttl = self.client._get_nonce_ttl(account.get_address(), tx_ttl)
             # build the transaction
-            tx, contract_id = txb.tx_contract_create(account.get_address(), self.bytecode, call_data, amount, deposit, gas, gas_price, vm_version,
+            tx, contract_id = txb.tx_contract_create(account.get_address(), self.bytecode, call_data,
+                                                     amount, deposit, gas, gas_price, vm_version, abi_version,
                                                      fee, ttl, nonce)
             # sign the transaction
             tx_signed, sg, tx_hash = self.client.sign_transaction(account, tx)
@@ -167,3 +181,13 @@ def decode_data(self, data, sophia_type):
             return reply.data.value, reply.data.type
         except OpenAPIClientException as e:
             raise ContractError(e)
+
+    def _get_vm_abi_versions(self):
+        """
+        Check the version of the node and retrieve the correct values for abi and vm version
+        """
+        if semver.match(self.client.api_version, "<=1.4.0"):
+            return CONTRACT_ROMA_VM, CONTRACT_ROMA_ABI
+        if semver.match(self.client.api_version, "<3.0.0"):
+            return CONTRACT_MINERVA_VM, CONTRACT_MINERVA_ABI
+        raise UnsupportedEpochVersion(f"Version {self.client.api_version} is not supported")

aeternity/hashing.py

@@ -89,7 +89,7 @@ def encode_rlp(prefix, data):
     :param data: the array that has to be encoded in rlp
     """
     if not isinstance(data, list):
-        raise ValueError("data to be encoded to rlp must be an array")
+        raise ValueError("data to be encoded to rlp must be a list")
     payload = rlp.encode(data)
     return encode(prefix, payload)
 
@@ -132,13 +132,17 @@ def namehash_encode(prefix, name):
     return encode(prefix, namehash(name))
 
 
-def _int(val: int) -> bytes:
+def _int(val: int, byte_length: int = None) -> bytes:
     """
     Encode and int to a big endian byte array
+    :param val: the value to encode
+    :param byte_length: number of bytes that should be used to encoded the number, by default is the minimum
     """
     if val == 0:
-        return val.to_bytes(1, byteorder='big')
-    return val.to_bytes((val.bit_length() + 7) // 8, byteorder='big')
+        size = 1 if byte_length is None else byte_length
+        return val.to_bytes(size, byteorder='big')
+    size = (val.bit_length() + 7) // 8 if byte_length is None else byte_length
+    return val.to_bytes(size, byteorder='big')
 
 
 def _binary(val):
@@ -168,15 +172,15 @@ def contract_id(owner_id, nonce):
     :param owner_id: the account creating the conctract
     :param nonce: the nonce of the contract creation transaction
     """
-    return hash_encode("ct", decode(owner_id) + _int(nonce))
+    return hash_encode(identifiers.CONTRACT_ID, decode(owner_id) + _int(nonce))
 
 
 def oracle_id(account_id):
     """
     Compute the oracle id of a oracle registration
     :parm account_id: the account registering the oracle
     """
-    return f"ok_{account_id[3:]}"
+    return f"{identifiers.ORACLE_ID}_{account_id[3:]}"
 
 
 def oracle_query_id(sender_id, nonce, oracle_id):
@@ -186,9 +190,7 @@ def oracle_query_id(sender_id, nonce, oracle_id):
     :param nonce: the nonce of the query transaction
     :param oracle_id: the oracle id
     """
-    def _int32(val):
-        return val.to_bytes(32, byteorder='big')
-    return hash_encode("oq", decode(sender_id) + _int32(nonce) + decode(oracle_id))
+    return hash_encode(identifiers.ORACLE_QUERY_ID, decode(sender_id) + _int(nonce, byte_length=32) + decode(oracle_id))
 
 
 def randint(upper_bound=2**64):

aeternity/identifiers.py

@@ -115,3 +115,26 @@
 OBJECT_TAG_POI = 60
 OBJECT_TAG_MICRO_BODY = 101
 OBJECT_TAG_LIGHT_MICRO_BLOCK = 102
+
+
+# VM Identifiers
+# vm version specification
+# https://github.com/aeternity/protocol/blob/master/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain
+NO_VM = 0
+VM_SOPHIA = 1
+VM_SOLIDITY = 2
+VM_SOPHIA_IMPROVEMENTS = 3
+# abi
+NO_ABI = 0
+ABI_SOPHIA = 1
+ABI_SOLIDITY = 2
+# Contracts identifiers
+# For Roma
+CONTRACT_ROMA_VM = 0  # this is to maintain retrocompatibility
+CONTRACT_ROMA_ABI = 1
+# For Minerva: 196609  # that is int.from_bytes(int(3).to_bytes(2, "big") + int(1).to_bytes(2, "big"), "big")
+CONTRACT_MINERVA_VM = 3
+CONTRACT_MINERVA_ABI = 1
+
+# Oracles
+ORACLE_DEFAULT_VM_VERSION = NO_VM

aeternity/openapi.py

@@ -52,16 +52,16 @@ def __init__(self, url, url_internal=None, debug=False, force_compatibility=Fals
         try:
             # load the openapi json file from the node
             self.api_def = requests.get(f"{url}/api").json()
-            api_version = self.api_def.get("info", {}).get("version", "unknown")
+            self.api_version = self.api_def.get("info", {}).get("version", "unknown")
             # retrieve the version of the node we are connecting to
-            match_min = semver.match(api_version, __compatibility__.get("from_version"))
-            match_max = semver.match(api_version, __compatibility__.get("to_version"))
+            match_min = semver.match(self.api_version, __compatibility__.get("from_version"))
+            match_max = semver.match(self.api_version, __compatibility__.get("to_version"))
             if (not match_min or not match_max) and not force_compatibility:
                 f, t = __compatibility__.get('from_version'), __compatibility__.get('to_version')
                 raise UnsupportedEpochVersion(
-                    f"unsupported epoch version {api_version}, supported version are {f} and {t}")
+                    f"unsupported node version {self.api_version}, supported version are {f} and {t}")
         except requests.exceptions.ConnectionError as e:
-            raise ConfigException(f"Error connecting to the epoch node at {self.api_url}, connection unavailable")
+            raise ConfigException(f"Error connecting to the node at {self.api_url}, connection unavailable")
         except Exception as e:
             raise UnsupportedEpochVersion(f"Unable to connect to the node: {e}")
 

aeternity/oracles.py

@@ -1,6 +1,6 @@
 import logging
 from aeternity import config, hashing
-from aeternity.identifiers import ORACLE_ID
+from aeternity.identifiers import ORACLE_ID, ORACLE_DEFAULT_VM_VERSION
 
 logger = logging.getLogger(__name__)
 
@@ -66,7 +66,7 @@ def register(self, account, query_format, response_format,
                  query_fee=config.ORACLE_DEFAULT_QUERY_FEE,
                  ttl_type=config.ORACLE_DEFAULT_TTL_TYPE_DELTA,
                  ttl_value=config.ORACLE_DEFAULT_TTL_VALUE,
-                 vm_version=config.ORACLE_DEFAULT_VM_VERSION,
+                 vm_version=ORACLE_DEFAULT_VM_VERSION,
                  fee=config.DEFAULT_FEE,
                  tx_ttl=config.DEFAULT_TX_TTL):
         """