Merge pull request #147 from aeternity/release/3.0.0

Release/3.0.0

Author: noandrea

.env

@@ -1,3 +1,4 @@
 # this is used by docker-compose.yml to for the node image tag
-TAG=v2.0.0
+NODE_TAG=v2.1.0
+COMPILER_TAG=v2.1.0
 

.gitignore

@@ -10,3 +10,4 @@ build
 coverage.xml
 docker-compose.override.yml
 test-results.xml
+.coverage

CHANGELOG.md

@@ -43,4 +43,9 @@ publish:
 publish-test:
 	@echo publish on test.pypi.org
 	twine upload --repository-url https://test.pypi.org/legacy/ dist/*
-	@echo done
+	@echo done
+
+changelog:
+	@echo build changelog
+	gitolog -t keepachangelog -s angular . -o CHANGELOG.md 
+	@echo done

Makefile

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

aeternity/__init__.py

@@ -9,10 +9,10 @@
 from aeternity import __version__
 
 from aeternity.node import NodeClient, Config
-from aeternity.transactions import TxSigner
-# from aeternity.oracle import Oracle, OracleQuery, NoOracleResponse
+from aeternity.transactions import TxSigner, TxBuilder
+from aeternity.identifiers import NETWORK_ID_MAINNET
 from . import utils, signing, aens, defaults, exceptions
-from aeternity.contract import Contract
+from aeternity.contract import CompilerClient
 
 from datetime import datetime, timezone
 
@@ -164,7 +164,7 @@ def _print_error(err, title="error", exit_code=0):
 ]
 
 _sign_options = [
-    click.option('--network-id', default=None, help="The network id to use when signing a transaction")
+    click.option('--network-id', default=NETWORK_ID_MAINNET, help="The network id to use when signing a transaction", show_default=True)
 ]
 
 _transaction_options = [
@@ -338,19 +338,20 @@ def account_balance(keystore_name, password, force, wait, json_):
 @click.argument('keystore_name', required=True)
 @click.argument('recipient_id', required=True)
 @click.argument('amount', required=True, type=int)
+@click.option('--payload', default="", help="Spend transaction payload")
 @global_options
 @account_options
 @online_options
 @transaction_options
 @sign_options
-def account_spend(keystore_name, recipient_id, amount, fee, ttl, nonce, password, network_id, force, wait, json_):
+def account_spend(keystore_name, recipient_id, amount, payload, fee, ttl, nonce, password, network_id, force, wait, json_):
     try:
         set_global_options(json_, force, wait)
         account, keystore_path = _account(keystore_name, password=password)
         account.nonce = nonce
         if not utils.is_valid_hash(recipient_id, prefix="ak"):
             raise ValueError("Invalid recipient address")
-        tx = _node_cli(network_id=network_id).spend(account, recipient_id, amount, tx_ttl=ttl, fee=fee)
+        tx = _node_cli(network_id=network_id).spend(account, recipient_id, amount, tx_ttl=ttl, fee=fee, payload=payload)
         _print_object(tx, title='spend transaction')
     except Exception as e:
         _print_error(e, exit_code=1)
@@ -420,8 +421,7 @@ def tx_broadcast(signed_transaction, force, wait, json_):
 def tx_spend(sender_id, recipient_id, amount,  ttl, fee, nonce, payload, json_):
     try:
         set_global_options(json_)
-        cli = _node_cli()
-        tx = cli.tx_builder.tx_spend(sender_id, recipient_id, amount, payload, fee, ttl, nonce)
+        tx = TxBuilder().tx_spend(sender_id, recipient_id, amount, payload, fee, ttl, nonce)
         # print the results
         _print_object(tx, title='spend tx')
     except Exception as e:
@@ -584,34 +584,101 @@ def name_transfer(keystore_name, domain, address, ttl, fee, nonce, password, net
 #
 #
 
-@click.group('contract', help='Deploy and execute contracts on the chain')
-def contract():
+@cli.group(help="Interact with Æternity smart contract compiler")
+def compiler():
     pass
 
 
-@contract.command(help="Compile a contract")
+@compiler.command('compile', help="Compile a contract")
+@click.option('--compiler-url', '-c', default='http://localhost:3080', envvar='COMPILER_URL', help='Aeternity compiler url', metavar='URL')
 @click.argument("contract_file")
-def contract_compile(contract_file):
+@global_options
+def contract_compile(contract_file, compiler_url, json_):
     try:
+        set_global_options(json_, False, False)
         with open(contract_file) as fp:
             code = fp.read()
-            c = _node_cli().Contract(Contract.SOPHIA)
+            c = CompilerClient(compiler_url)
             result = c.compile(code)
-            _print_object({"bytecode", result}, title="contract")
+            if click.confirm(f'Save contract bytecode to file ({contract_file}.bin) ?', default=True, show_default=True):
+                with open(f"{contract_file}.bin", "w") as fp:
+                    fp.write(result.bytecode)
+            _print_object(result, title="contract")
+    except Exception as e:
+        _print_error(e, exit_code=1)
+
+
+@compiler.command('aci', help="Get the aci of a contract")
+@click.option('--compiler-url', '-c', default='http://localhost:3080', envvar='COMPILER_URL', help='Aeternity compiler url', metavar='URL')
+@click.argument("contract_file")
+@global_options
+def contract_aci(contract_file, compiler_url, json_):
+    try:
+        set_global_options(json_, False, False)
+        with open(contract_file) as fp:
+            code = fp.read()
+            c = CompilerClient(compiler_url)
+            result = c.aci(code)
+            _print_object(result, title="contract")
+    except Exception as e:
+        _print_error(e, exit_code=1)
+
+
+@compiler.command('encode-calldata', help="Enocode the calldata to invoke a contract")
+@click.option('--compiler-url', '-c', default='http://localhost:3080', envvar='COMPILER_URL', help='Aeternity compiler url', metavar='URL')
+@click.argument("contract_file")
+@click.argument("function_name")
+@click.option("--arguments", default=None, help="Argument of the function if any, comma separated")
+@global_options
+def contract_encode_calldata(contract_file, function_name, arguments, compiler_url, json_):
+    try:
+        set_global_options(json_, False, False)
+        with open(contract_file) as fp:
+            code = fp.read()
+            c = CompilerClient(compiler_url)
+            arguments = [] if arguments is None else arguments.split(",")
+            result = c.encode_calldata(code, function_name, arguments=arguments)
+            _print_object(result, title="contract")
+    # except Exception as e:
+    #     _print_error(e, exit_code=1)
+    finally:
+        pass
+
+
+@compiler.command('decode-data', help="Decode the data retrieve from a contract")
+@click.option('--compiler-url', '-c', default='http://localhost:3080', envvar='COMPILER_URL', help='Aeternity compiler url', metavar='URL')
+@click.argument("sophia_type")
+@click.argument("encoded_data")
+@global_options
+def contract_decode_data(contract_file, encoded_data, sophia_type, compiler_url, json_):
+    try:
+        set_global_options(json_, False, False)
+        c = CompilerClient(compiler_url)
+        result = c.decode_data(sophia_type, encoded_data)
+        _print_object(result, title="contract")
     except Exception as e:
         _print_error(e, exit_code=1)
 
 
-@contract.command('deploy', help='Deploy a contract on the chain')
+@cli.group(help='Deploy and execute contracts on the chain')
+def contracts():
+    pass
+
+
+@contracts.command('deploy', help='Deploy a contract on the chain')
 @click.argument('keystore_name', required=True)
-@click.argument("contract_file", required=True)
+@click.argument("bytecode_file", required=True)
+@click.option("--init-calldata", default=defaults.CONTRACT_INIT_CALLDATA, help="The calldata for the init function", show_default=True)
 @click.option("--gas", default=defaults.CONTRACT_GAS, help='Amount of gas to deploy the contract', show_default=True)
+@click.option("--amount", default=defaults.CONTRACT_AMOUNT, help='Amount of tokens to transfer to the contract', show_default=True)
+@click.option("--gas-price", default=defaults.CONTRACT_GAS_PRICE, help='The gas price used to execute the contract init function', show_default=True)
+@click.option("--deposit", default=defaults.CONTRACT_AMOUNT, help='A initial deposit to the contract', show_default=True)
 @global_options
 @account_options
 @online_options
 @transaction_options
 @sign_options
-def contract_deploy(keystore_name, contract_file, gas, password, network_id, force, wait, json_):
+def contract_deploy(keystore_name, bytecode_file, init_calldata, gas, gas_price, amount, deposit, password, ttl, fee, nonce, network_id, force, wait, json_):
     """
     Deploy a contract to the chain and create a deploy descriptor
     with the contract informations that can be use to invoke the contract
@@ -621,36 +688,22 @@ def contract_deploy(keystore_name, contract_file, gas, password, network_id, for
     source file. Multiple deploy of the same contract file will generate different
     deploy descriptor
     """
+    print("Not yet implemented")
+    return
     try:
-        with open(contract_file) as fp:
+        with open(bytecode_file) as fp:
             set_global_options(json_, force, wait)
             account, _ = _account(keystore_name, password=password)
-            code = fp.read()
-            contract = _node_cli(network_id=network_id).Contract(code)
-            tx = contract.tx_create(account, gas=gas)
-            # save the contract data
-            contract_data = {
-                'source': contract.source_code,
-                'bytecode': contract.bytecode,
-                'id': contract.id,
-                'transaction': tx.tx_hash,
-                'owner': account.get_address(),
-                'created_at': datetime.now().isoformat('T')
-            }
-            # write the contract data to a file
-            deploy_descriptor = f"{contract_file}.deploy.{contract.id[3:]}.json"
-            with open(deploy_descriptor, 'w') as fw:
-                json.dump(contract_data, fw, indent=2)
-            _print_object({
-                "Contract id": contract.id,
-                "Transaction hash": tx.tx_hash,
-                "Deploy descriptor": deploy_descriptor,
-            }, title="contract")
+            bytecode = fp.read()
+            contract = _node_cli(network_id=network_id).Contract()
+            tx = contract.create(account, bytecode, init_calldata=init_calldata, gas=gas, amount=amount,
+                                 gas_price=gas_price, deposit=deposit, tx_ttl=ttl, fee=fee)
+            _print_object(tx, title="contract create")
     except Exception as e:
         _print_error(e, exit_code=1)
 
 
-@contract.command('call', help='Execute a function of the contract')
+@contracts.command('call', help='Execute a function of the contract')
 @click.argument('keystore_name', required=True)
 @click.argument("deploy_descriptor", required=True)
 @click.argument("function", required=True)
@@ -663,6 +716,8 @@ def contract_deploy(keystore_name, contract_file, gas, password, network_id, for
 @transaction_options
 @sign_options
 def contract_call(keystore_name, deploy_descriptor, function, params, return_type, gas,  password, network_id, force, wait, json_):
+    print("Not yet implemented")
+    return
     try:
         with open(deploy_descriptor) as fp:
             contract = json.load(fp)
@@ -674,16 +729,23 @@ def contract_call(keystore_name, deploy_descriptor, function, params, return_typ
             account, _ = _account(keystore_name, password=password)
 
             contract = _node_cli(network_id=network_id).Contract(source, bytecode=bytecode, address=address)
-            tx, result = contract.tx_call(account, function, params, gas=gas)
+            tx = contract.tx_call(account, function, params, gas=gas)
             _print_object(tx, "contract call")
-            if result.return_type == 'ok':
-                value, remote_type = contract.decode_data(result.return_value, return_type)
-                _print_object({
-                    'Return value': value,
-                    'Return remote type': remote_type,
-                })
-
-            pass
+    except Exception as e:
+        _print_error(e, exit_code=1)
+
+
+@contracts.command('call-info', help='Retrieve the result of a contract call if any')
+@click.argument('tx_hash', required=True)
+@global_options
+@online_options
+def contract_call_info(tx_hash, force, wait, json_):
+    print("Not yet implemented")
+    return
+    try:
+        contract = _node_cli().Contract()
+        call_object = contract.get_call_object(tx_hash)
+        _print_object(call_object, "contract call object")
     except Exception as e:
         _print_error(e, exit_code=1)
 

aeternity/__main__.py

@@ -167,14 +167,12 @@ def claim(self, account, name_salt, preclaim_tx_hash, fee=defaults.FEE, tx_ttl=d
         safe_height = self.preclaimed_block_height + self.client.config.key_block_confirmation_num
         if current_height < safe_height:
             raise NameTooEarlyClaim(f"It is not safe to execute the name claim before height {safe_height}, current height: {current_height}")
-        # name encode name
-        name = hashing.name_id(self.domain)
         # 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)
         # create transaction
-        tx = txb.tx_name_claim(account.get_address(), name, self.preclaim_salt, fee, ttl, nonce)
+        tx = txb.tx_name_claim(account.get_address(), self.domain, self.preclaim_salt, fee, ttl, nonce)
         # sign the transaction
         tx_signed = self.client.sign_transaction(account, tx.tx)
         # post the transaction to the chain