Merge pull request #6 from oasisprotocol/ZigaMr/feat/bump-sapphirepy-version

Update for new sapphirepy version, add async/websocket tests

Author: ZigaMr

README.md

@@ -4,16 +4,16 @@ This is a skeleton for confidential Oasis dApps in Python.
 
 ## Prerequisites
 
-This project was tested on python 3.10, but should work with most 
+This project was tested on python 3.12, but should work with most
 python3 versions. 
 Use pyenv to handle multiple python installations.
 
 ## Installation
 
 1. Initialize an environment using preferred environment manager 
-(venv, pipx...) ```python3 -m venv my_env```. 
-2. Install the ```oasis-sapphire-py``` client library and 
-other dependencies from requirements.txt ```pip install -r requirements.txt```.
+   (venv, pipx...) ```python3 -m venv my_env```.
+2. Install the [`oasis-sapphire-py`](https://pypi.org/project/oasis-sapphire-py/) client library and
+   other dependencies from requirements.txt ```pip install -r requirements.txt```.
 
 ## Setup
 
@@ -36,7 +36,7 @@ Open main.py which contains a simple starter example.
 
 ### Initialization
 
-The ```ContractUtility``` class is used to compile and deploy the contracts, 
+The `ContractUtility` class is used to compile and deploy the contracts, 
 based on the network name (sapphire, sapphire-testnet, sapphire-localnet).
 The private key used to deploy the contract is fetched from the PRIVATE_KEY 
 environment variable.
@@ -62,7 +62,7 @@ ContractUtility.setup_and_compile_contract("MessageBox")
 ### Deploying the contract
 
 ```python
-contract_utility.deploy_contract("MessageBox")
+await contract_utility.deploy_contract("MessageBox)
 ```
 Provide the contract name, in the starter example case 
 we use the provided **MessageBox** without the .sol extension.

main.py

@@ -1,32 +1,44 @@
 #!/usr/bin/env python3
 
+import asyncio
 from src.ContractUtility import ContractUtility
 from src.MessageBox import set_message, get_message
 import argparse
 
 
-def main():
+async def async_main():
     """
     Main method for the Python CLI tool.
 
     :return: None
     """
     parser = argparse.ArgumentParser(
-        description="A Python CLI tool for compiling, deploying, and interacting with smart contracts."
+        description="""A Python CLI tool for compiling,
+                    deploying, and interacting with smart contracts."""
     )
 
     subparsers = parser.add_subparsers(dest="command", help="Subcommands")
 
     # Subparser for compile
-    compile_parser = subparsers.add_parser("compile", help="Compile the source code")
+    compile_parser = subparsers.add_parser(
+        "compile",
+        help="Compile the source code"
+        )
     compile_parser.add_argument(
-        "--contract", help="Name of the contract to compile", default="MessageBox"
+        "--contract",
+        help="Name of the contract to compile",
+        default="MessageBox"
     )
 
     # Subparser for deploy
-    deploy_parser = subparsers.add_parser("deploy", help="Deploy the smart contract")
+    deploy_parser = subparsers.add_parser(
+        "deploy",
+        help="Deploy the smart contract"
+        )
     deploy_parser.add_argument(
-        "--contract", help="Name of the contract to deploy", default="MessageBox"
+        "--contract",
+        help="Name of the contract to deploy",
+        default="MessageBox"
     )
     deploy_parser.add_argument(
         "--network",
@@ -66,24 +78,36 @@ def main():
         required=True,
     )
 
-
     arguments = parser.parse_args()
 
     match arguments.command:
         case "compile":
-            # Use class method which does not require an instance of ContractUtility.
-            # This is to avoid setting up the Web3 instance which requires the PRIVATE_KEY.
+            # Use class method which does not
+            # require an instance of ContractUtility.
+            # This is to avoid setting up the Web3 instance
+            # which requires the PRIVATE_KEY.
             ContractUtility.setup_and_compile_contract(arguments.contract)
         case "deploy":
             contract_utility = ContractUtility(arguments.network)
-            contract_utility.deploy_contract(arguments.contract)
+            await contract_utility.deploy_contract(arguments.contract)
         case "setMessage":
-            set_message(arguments.address, arguments.message, arguments.network)
+            await set_message(
+                arguments.address,
+                arguments.message,
+                arguments.network
+                )
         case "message":
-            get_message(arguments.address, arguments.network)
+            await get_message(arguments.address, arguments.network)
         case _:
             parser.print_help()
 
 
+def main():
+    """
+    Entry point that runs the async main function
+    """
+    asyncio.run(async_main())
+
+
 if __name__ == "__main__":
     main()

requirements.txt

@@ -1,4 +1,6 @@
 flake8
 py-solc-x
 pytest
-oasis-sapphire-py
+pytest-asyncio
+oasis-sapphire-py==0.4.*
+web3==7.*

src/ContractUtility.py

@@ -1,10 +1,12 @@
 import os
 from pathlib import Path
 from solcx import compile_standard, install_solc
-from eth_account.signers.local import LocalAccount
-from eth_account import Account
 
-from src.utils import setup_web3_middleware, get_contract, process_json_file
+from src.utils import (
+    setup_web3_middleware,
+    get_contract,
+    process_json_file,
+)
 
 
 class ContractUtility:
@@ -24,6 +26,7 @@ def __init__(self, network_name: str):
     def setup_and_compile_contract(
         cls, contract_name: str = "MessageBox", SOLIDITY_VERSION: str = "0.8.0"
     ) -> str:
+        # This remains synchronous as compilation doesn't need to be async.
         install_solc(SOLIDITY_VERSION)
         contract_dir = (Path(__file__).parent.parent / "contracts").resolve()
         contract_dir.mkdir(parents=True, exist_ok=True)
@@ -33,10 +36,15 @@ def setup_and_compile_contract(
         compiled_sol = compile_standard(
             {
                 "language": "Solidity",
-                "sources": {f"{contract_name}.sol": {"content": contract_source_code}},
+                "sources": {f"{contract_name}.sol":
+                            {"content": contract_source_code}},
                 "settings": {
                     "outputSelection": {
-                        "*": {"*": ["abi", "metadata", "evm.bytecode", "evm.sourceMap"]}
+                        "*": {"*": ["abi",
+                                    "metadata",
+                                    "evm.bytecode",
+                                    "evm.sourceMap"
+                                    ]}
                     }
                 },
             },
@@ -52,10 +60,13 @@ def setup_and_compile_contract(
         print(f"Compiled contract {contract_name} {output_path}")
         return compiled_sol
 
-    def deploy_contract(self, contract_name: str):
+    async def deploy_contract(self, contract_name: str):
         abi, bytecode = get_contract(contract_name)
         contract = self.w3.eth.contract(abi=abi, bytecode=bytecode)
-        tx_hash = contract.constructor().transact({"gasPrice": self.w3.eth.gas_price})
-        tx_receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
+        gas_price = await self.w3.eth.gas_price
+        tx_hash = await contract.constructor().transact({
+            "gasPrice": gas_price
+            })
+        tx_receipt = await self.w3.eth.wait_for_transaction_receipt(tx_hash)
         print(f"Contract deployed at {tx_receipt.contractAddress}")
         return tx_receipt.contractAddress

src/MessageBox.py

@@ -3,32 +3,47 @@
 from src.utils import get_contract
 
 
-def set_message(
-    address: str, message: str, network_name: Optional[str] = "sapphire-localnet"
+async def set_message(
+    address: str,
+    message: str,
+    network_name: Optional[str] = "sapphire-localnet"
 ) -> None:
     contract_utility = ContractUtility(network_name)
 
     abi, bytecode = get_contract("MessageBox")
 
-    contract = contract_utility.w3.eth.contract(address=address, abi=abi)
+    contract = contract_utility.w3.eth.contract(
+        address=address,
+        abi=abi
+        )
 
-    # Set a message
-    tx_hash = contract.functions.setMessage(message).transact(
-        {"gasPrice": contract_utility.w3.eth.gas_price}
+    gas_price = await contract_utility.w3.eth.gas_price
+    tx_hash = await contract.functions.setMessage(message).transact(
+        {"gasPrice": gas_price}
     )
-    tx_receipt = contract_utility.w3.eth.wait_for_transaction_receipt(tx_hash)
-    print(f"Message set. Transaction hash: {tx_receipt.transactionHash.hex()}")
-
-
-def get_message(address: str, network_name: Optional[str] = "sapphire-localnet") -> str:
+    tx_receipt = await contract_utility.w3.eth.wait_for_transaction_receipt(
+        tx_hash
+        )
+    print(f"""Message set.
+          Transaction hash: {tx_receipt.transactionHash.hex()}"""
+          )
+
+
+async def get_message(
+        address: str,
+        network_name: Optional[str] = "sapphire-localnet"
+        ) -> str:
     contract_utility = ContractUtility(network_name)
 
     abi, bytecode = get_contract("MessageBox")
 
-    contract = contract_utility.w3.eth.contract(address=address, abi=abi)
+    contract = contract_utility.w3.eth.contract(
+        address=address,
+        abi=abi
+        )
     # Retrieve message from contract
-    message = contract.functions.message().call()
-    author = contract.functions.author().call()
+    message = await contract.functions.message().call()
+    author = await contract.functions.author().call()
 
     print(f"Retrieved message: {message}")
     print(f"Author: {author}")

src/utils.py

@@ -1,24 +1,36 @@
-from web3 import Web3
-from web3.middleware import construct_sign_and_send_raw_middleware
+from web3 import Web3, AsyncWeb3
+from web3.middleware import SignAndSendRawMiddlewareBuilder
+
 from eth_account.signers.local import LocalAccount
 from eth_account import Account
 from sapphirepy import sapphire
 import json
 from pathlib import Path
+from typing import Union
 
 
-def setup_web3_middleware(network_name: str, PRIVATE_KEY: str) -> Web3:
+def setup_web3_middleware(
+        network_name: str,
+        PRIVATE_KEY: str,
+        ) -> Union[Web3, AsyncWeb3]:
     if not all(
         [
             PRIVATE_KEY,
         ]
     ):
-        raise Warning("Missing required environment variables. Please set PRIVATE_KEY.")
+        raise Warning("""Missing required environment variables.
+                      Please set PRIVATE_KEY.""")
 
     account: LocalAccount = Account.from_key(PRIVATE_KEY)
-
-    w3 = Web3(Web3.HTTPProvider(sapphire.NETWORKS[network_name]))
-    w3.middleware_onion.add(construct_sign_and_send_raw_middleware(account))
+    w3 = AsyncWeb3(
+            AsyncWeb3.AsyncHTTPProvider(
+                sapphire.NETWORKS[network_name]
+                )
+            )
+
+    w3.middleware_onion.add(
+        SignAndSendRawMiddlewareBuilder.build(account)
+        )
     w3 = sapphire.wrap(w3, account)
     # w3.eth.set_gas_price_strategy(rpc_gas_price_strategy)
     w3.eth.default_account = account.address
@@ -44,5 +56,8 @@ def get_contract(contract_name: str):
     contract_data = compiled_contract["contracts"][f"{contract_name}.sol"][
         contract_name
     ]
-    abi, bytecode = contract_data["abi"], contract_data["evm"]["bytecode"]["object"]
+    abi, bytecode = (
+        contract_data["abi"],
+        contract_data["evm"]["bytecode"]["object"]
+        )
     return abi, bytecode