ethernity-cloud-sdk-py 0.2.0__tar.gz → 0.2.2__tar.gz

{ethernity_cloud_sdk_py-0.2.0/ethernity_cloud_sdk_py.egg-info → ethernity_cloud_sdk_py-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ethernity-cloud-sdk-py
-Version: 0.2.0
+Version: 0.2.2
 Summary: Ethernity Cloud SDK Python
 Home-page: https://github.com/ethernity-cloud/ethernity-cloud-sdk-py
 Author: Ethernity Cloud Team
@@ -31,6 +31,7 @@ This project provides a set of tools and scripts to work with the Ethernity Clou
 
 ## Table of Contents
 
+- [Pre-requisites](#pre-requisites)
 - [Installation](#installation)
 - [Usage](#usage)
   - [Scripts](#scripts)
@@ -38,6 +39,22 @@ This project provides a set of tools and scripts to work with the Ethernity Clou
 - [Contributing](#contributing)
 - [License](#license)
 
+## Pre-requisites
+Linux:
+- build-essentials
+- Python 3.10+
+- docker 
+- docker-compose
+
+Windows:
+- Microsoft Visual Studio Community 2022+ (https://visualstudio.microsoft.com/)
+  - MSVC++ 14.3+ build tools
+  - C++ CMake tools for Windows
+  - Windows SDK (for current running version)
+  - Reboot required
+- Python 3.13
+- Docker Desktop
+
 ## Installation
 
 To install the package and its dependencies, run:
@@ -55,13 +72,6 @@ pip install ethernity-cloud-sdk-py
 
 After installation, you can use the provided scripts to build, publish, and initialize your project.
 
-## Pre-requisites
-The sdk requires the following to be installed on your system:
-- python 3.10+
-- docker (daemon running in the background for build and publish scripts)
-- docker-compose (for the build and publish scripts)
-
-
 ## Operating System compatibility
 The sdk has been tested on the following operating systems:
 - Windows 10
@@ -145,7 +155,7 @@ def execute_task() -> None:
         code,
         "0xd58f5C1834279ABD601df85b3E4b2323aDD4E75e",
         resources,
-        os.getenv("ENCLAVE_NAME_TRUSTEDZONE", ""),
+        os.getenv("TRUSTED_ZONE_IMAGE", ""),
     )
 
 

{ethernity_cloud_sdk_py-0.2.0 → ethernity_cloud_sdk_py-0.2.2}/README.md

@@ -13,6 +13,7 @@ This project provides a set of tools and scripts to work with the Ethernity Clou
 
 ## Table of Contents
 
+- [Pre-requisites](#pre-requisites)
 - [Installation](#installation)
 - [Usage](#usage)
   - [Scripts](#scripts)
@@ -20,6 +21,22 @@ This project provides a set of tools and scripts to work with the Ethernity Clou
 - [Contributing](#contributing)
 - [License](#license)
 
+## Pre-requisites
+Linux:
+- build-essentials
+- Python 3.10+
+- docker 
+- docker-compose
+
+Windows:
+- Microsoft Visual Studio Community 2022+ (https://visualstudio.microsoft.com/)
+  - MSVC++ 14.3+ build tools
+  - C++ CMake tools for Windows
+  - Windows SDK (for current running version)
+  - Reboot required
+- Python 3.13
+- Docker Desktop
+
 ## Installation
 
 To install the package and its dependencies, run:
@@ -37,13 +54,6 @@ pip install ethernity-cloud-sdk-py
 
 After installation, you can use the provided scripts to build, publish, and initialize your project.
 
-## Pre-requisites
-The sdk requires the following to be installed on your system:
-- python 3.10+
-- docker (daemon running in the background for build and publish scripts)
-- docker-compose (for the build and publish scripts)
-
-
 ## Operating System compatibility
 The sdk has been tested on the following operating systems:
 - Windows 10
@@ -127,7 +137,7 @@ def execute_task() -> None:
         code,
         "0xd58f5C1834279ABD601df85b3E4b2323aDD4E75e",
         resources,
-        os.getenv("ENCLAVE_NAME_TRUSTEDZONE", ""),
+        os.getenv("TRUSTED_ZONE_IMAGE", ""),
     )
 
 

{ethernity_cloud_sdk_py-0.2.0 → ethernity_cloud_sdk_py-0.2.2}/ethernity_cloud_sdk_py/commands/build.py

@@ -1,22 +1,35 @@
 import os
 import sys
 import subprocess
+
 from pathlib import Path
-from dotenv import load_dotenv
+from ethernity_cloud_sdk_py.commands.config import Config, config
+
+config = Config(Path(".config.json").resolve())
+config.load()
+
+
+#print("Configuration loaded:", config.config)
 
 
 def main():
     # Load environment variables from .env file
-    current_dir = os.getcwd()
-    dotenv_path = os.path.join(current_dir, ".env")
-    print(f"Looking for .env file at: {dotenv_path}")
-    load_dotenv(dotenv_path=dotenv_path)
-    service_type = os.getenv("SERVICE_TYPE")
-    print(f"Service type: {service_type}")
+    version = config.read("VERSION")
+    project_name = config.read("PROJECT_NAME")
+    version += 1
+    #print("Incrementing version to", version)
+
+    config.write("VERSION", version)
+    config.write("IPFS_HASH", "")
+    service_type = config.read("SERVICE_TYPE")
+    print(f"""\u276f\u276f Initializing build process
+   Project name: {project_name}
+   Version: {version}""")
+
     if service_type == "Nodenithy":
-        print("Adding prerequisites for Nodenithy...")
+        #print("Adding prerequisites for Nodenithy...")
         script_path = Path(__file__).resolve().parent / "nodenithy" / "build.py"
-        print(f"Running script: {script_path}")
+        #print(f"Running script: {script_path}")
         try:
             subprocess.run(["python", str(script_path)], check=True)
             print(
@@ -24,13 +37,13 @@ def main():
             )
         except subprocess.CalledProcessError:
             print("Error running the build script.")
-            sys.exit(1)
+            exit(1)
     elif service_type == "Pynithy":
-        print("Adding prerequisites for Pynithy...")
+        #print("Adding prerequisites for Pynithy...")
         import ethernity_cloud_sdk_py.commands.pynithy.build as buildScript
 
         # script_path = Path(__file__).resolve().parent / "pynithy" / "build.py"
-        print(f"Running script: buildScript")
+        #print(f"Running script: buildScript")
         # try:
         #     subprocess.run(["python", str(script_path)], check=True)
         #     print(
@@ -38,7 +51,7 @@ def main():
         #     )
         # except subprocess.CalledProcessError:
         #     print("Error running the build script.")
-        #     sys.exit(1)
+        #     exit(1)
         try:
             buildScript.main()
             print(
@@ -50,10 +63,10 @@ Build process was successful! You can now proceed to publish by running:
             )
         except Exception as e:
             print(f"Error running the build script: {e}")
-            sys.exit(1)
+            exit(1)
     else:
         print("Something went wrong")
-        sys.exit(1)
+        exit(1)
 
 
 if __name__ == "__main__":

ethernity_cloud_sdk_py-0.2.2/ethernity_cloud_sdk_py/commands/config.py

@@ -0,0 +1,65 @@
+import json
+
+class Config:
+    def __init__(self, file_path):
+        """
+        Initialize the Config class with the path to the configuration file.
+
+        Args:
+            file_path (str): Path to the JSON configuration file.
+        """
+        self.file_path = file_path
+        self.config = {}
+
+    def load(self):
+        """
+        Load the JSON configuration file into the class's dictionary.
+
+        Returns:
+            dict: The loaded configuration dictionary.
+        """
+        try:
+            with open(self.file_path, 'r') as f:
+                self.config = json.load(f)
+            if not isinstance(self.config, dict):
+                raise ValueError("JSON file must contain a dictionary.")
+        except FileNotFoundError:
+            print(f"File not found: {self.file_path}. Initializing with an empty configuration.")
+            self.config = {}
+        except json.JSONDecodeError as e:
+            print(f"Error decoding JSON file: {e}. Initializing with an empty configuration.")
+            self.config = {}
+        return self.config
+
+    def read(self, variable):
+        """
+        Read the value of a specific variable from the configuration.
+
+        Args:
+            variable (str): The variable key to retrieve.
+
+        Returns:
+            Any: The value associated with the variable, or None if not found.
+        """
+        return self.config.get(variable, None)
+
+    def write(self, variable, value):
+        """
+        Write or update a variable in the configuration and save it to the file.
+
+        Args:
+            variable (str): The variable key to write or update.
+            value (Any): The value to set for the variable.
+
+        Returns:
+            dict: The updated configuration dictionary.
+        """
+        self.config[variable] = value
+        try:
+            with open(self.file_path, 'w') as f:
+                json.dump(self.config, f, indent=4)
+        except Exception as e:
+            print(f"Error writing to file: {e}")
+        return self.config
+
+config = None

{ethernity_cloud_sdk_py-0.2.0 → ethernity_cloud_sdk_py-0.2.2}/ethernity_cloud_sdk_py/commands/init.py

@@ -4,7 +4,11 @@ import shutil
 import subprocess
 import re
 from pathlib import Path
-from dotenv import load_dotenv, set_key
+from ethernity_cloud_sdk_py.commands.config import Config, config
+
+config = Config(Path(".config.json").resolve())
+config.load()
+
 
 # For accessing package resources
 try:
@@ -13,29 +17,19 @@ except ImportError:
     # For Python versions < 3.7
     from importlib_resources import path as resources_path  # type: ignore
 
+config = None
 
-def write_env(key, value, env_file=".env"):
-    """
-    Write or update key-value pairs in a .env file in the current working directory.
+def initialize_config(file_path):
     """
-    env_path = os.path.join(os.getcwd(), env_file)
-    if not os.path.exists(env_path):
-        with open(env_path, "w") as f:
-            f.write(f"{key}={value}\n")
-    else:
-        replaced = False
-        with open(env_path, "r") as f:
-            lines = f.readlines()
-        with open(env_path, "w") as f:
-            for line in lines:
-                if line.startswith(f"{key}="):
-                    f.write(f"{key}={value}\n")
-                    replaced = True
-                else:
-                    f.write(line)
-            if not replaced:
-                f.write(f"{key}={value}\n")
+    Initialize the global config variable with the specified file path.
 
+    Args:
+        file_path (str): Path to the configuration file.
+    """
+    global config
+    config = Config(file_path)
+    config.load()
+    #print("Configuration loaded:", config.config)
 
 def get_project_name():
     """
@@ -132,30 +126,9 @@ def main():
     )
     import ethernity_cloud_sdk_py.commands.pynithy.run.image_registry as image_registry
 
-    # Execute the external script (image_registry.py)
-    # script_path = (
-    #     Path(__file__).resolve().parent / "pynithy" / "run" / "image_registry.py"
-    # )
     print(f"Running script image_registry...")
     print(os.getcwd())
-    # if not script_path.exists():
-    #     print(f"Error: Script {script_path} not found.")
-    #     sys.exit(1)
-
-    # try:
-    #     subprocess.run(
-    #         [
-    #             "python",
-    #             str(script_path),
-    #             blockchain_network.replace(" ", "_"),
-    #             project_name.replace(" ", "-"),
-    #             "v3",
-    #         ],
-    #         check=True,
-    #     )
-    # except subprocess.CalledProcessError as e:
-    #     print(f"Error executing script {script_path}")
-    #     sys.exit(1)
+  
     image_registry.main(
         blockchain_network.replace(" ", "_"),
         project_name.replace(" ", "-"),
@@ -203,67 +176,35 @@ def main():
             shutil.copytree(
                 src_path, os.path.join(os.getcwd(), "src"), dirs_exist_ok=True
             )
-        # Simulate copying files
-        # script_dir = os.path.dirname(os.path.abspath(__file__))
-
-        # source_src = os.path.join(script_dir, "src")
-        # target_src = "src/"
-        # # source_public = os.path.join(script_dir, "public")
-        # # target_public = "public/"
-
-        # shutil.copytree(source_src, target_src, dirs_exist_ok=True)
-        # shutil.copytree(source_public, target_public, dirs_exist_ok=True)
-        # print("Installing required packages...")
-        # # Simulate npm install
-        # try:
-        #     subprocess.run(
-        #         [
-        #             "npm",
-        #             "install",
-        #             "@ethernity-cloud/runner@0.0.26",
-        #             "@testing-library/jest-dom@5.17.0",
-        #             "@testing-library/react@13.4.0",
-        #             "@testing-library/user-event@13.5.0",
-        #             "react@18.3.1",
-        #             "react-dom@18.3.1",
-        #             "react-scripts@5.0.1",
-        #             "web-vitals@2.1.4",
-        #             "web3@4.9.0",
-        #             "dotenv@16.4.5",
-        #         ],
-        #         check=True,
-        #     )
-        # except subprocess.CalledProcessError as e:
-        #     print("Error installing npm packages.")
-        #     sys.exit(1)
+       
     else:
         print(
             "Define backend functions in src/serverless to be available for cli interaction."
         )
 
-    write_env("PROJECT_NAME", project_name.replace(" ", "_"))
-    write_env("SERVICE_TYPE", service_type)
+    config.write("PROJECT_NAME", project_name.replace(" ", "_"))
+    config.write("SERVICE_TYPE", service_type)
     if service_type == "Custom":
-        write_env("BASE_IMAGE_TAG", base_image_tag or "")
-        write_env("DOCKER_REPO_URL", docker_repo_url)
-        write_env("DOCKER_LOGIN", docker_login)
-        write_env("DOCKER_PASSWORD", docker_password)
+        config.write("BASE_IMAGE_TAG", base_image_tag or "")
+        config.write("DOCKER_REPO_URL", docker_repo_url)
+        config.write("DOCKER_LOGIN", docker_login)
+        config.write("DOCKER_PASSWORD", docker_password)
     elif service_type == "Nodenithy":
-        write_env("BASE_IMAGE_TAG", "")
-        write_env("DOCKER_REPO_URL", "")
-        write_env("DOCKER_LOGIN", "")
-        write_env("DOCKER_PASSWORD", "")
+        config.write("BASE_IMAGE_TAG", "")
+        config.write("DOCKER_REPO_URL", "")
+        config.write("DOCKER_LOGIN", "")
+        config.write("DOCKER_PASSWORD", "")
     elif service_type == "Pynithy":
-        write_env("BASE_IMAGE_TAG", "")
-        write_env("DOCKER_REPO_URL", "")
-        write_env("DOCKER_LOGIN", "")
-        write_env("DOCKER_PASSWORD", "")
-    write_env("BLOCKCHAIN_NETWORK", blockchain_network.replace(" ", "_"))
-    write_env("IPFS_ENDPOINT", custom_url)
-    write_env("IPFS_TOKEN", ipfs_token or "")
-    write_env("VERSION", "v1")
-
-    write_env(
+        config.write("BASE_IMAGE_TAG", "")
+        config.write("DOCKER_REPO_URL", "")
+        config.write("DOCKER_LOGIN", "")
+        config.write("DOCKER_PASSWORD", "")
+    config.write("BLOCKCHAIN_NETWORK", blockchain_network.replace(" ", "_"))
+    config.write("IPFS_ENDPOINT", custom_url)
+    config.write("IPFS_TOKEN", ipfs_token or "")
+    config.write("VERSION", "v1")
+
+    config.write(
         "TRUSTED_ZONE_IMAGE",
         f"{'ecld' if 'polygon' in blockchain_network.lower() else 'etny'}-{service_type.lower()}-{'testnet' if 'testnet' in blockchain_network.lower() else ''}",
     )
@@ -280,8 +221,4 @@ To start the build process run:
 
     ecld-build
         """
-    )
-
-
-if __name__ == "__main__":
-    main()
+    )

ethernity_cloud_sdk_py-0.2.2/ethernity_cloud_sdk_py/commands/private_key.py

@@ -0,0 +1,120 @@
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import padding
+from web3 import Web3
+from eth_account import Account
+import os
+import base64
+
+from pathlib import Path
+from ethernity_cloud_sdk_py.commands.config import Config, config
+
+config = Config(Path(".config.json").resolve())
+config.load()
+
+
+# Constants for key derivation
+SALT_LENGTH = 16  # Length of the salt
+ITERATIONS = 100000  # PBKDF2 iterations
+KEY_LENGTH = 32  # AES 256-bit key
+
+class PrivateKeyManager:
+    def __init__(self, password: str):
+        """Initialize with a password for key derivation."""
+        self.password = password
+
+    def derive_key(self, salt: bytes) -> bytes:
+        """Derive a key from the password using PBKDF2."""
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=KEY_LENGTH,
+            salt=salt,
+            iterations=ITERATIONS,
+            backend=default_backend()
+        )
+        return kdf.derive(self.password.encode())
+
+    def encrypt_private_key(self, private_key: str) -> str:
+        """Encrypt the private key using the password."""
+        salt = os.urandom(SALT_LENGTH)  # Generate a random salt
+        key = self.derive_key(salt)
+
+        # Create AES cipher
+        iv = os.urandom(16)  # AES block size is 16 bytes
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+        encryptor = cipher.encryptor()
+
+        # Pad the private key to be a multiple of the block size
+        padder = padding.PKCS7(algorithms.AES.block_size).padder()
+        padded_data = padder.update(private_key.encode()) + padder.finalize()
+
+        # Encrypt the private key
+        encrypted_private_key = encryptor.update(padded_data) + encryptor.finalize()
+
+        # Return the encrypted key and salt (base64-encoded for storage)
+        return base64.b64encode(salt + iv + encrypted_private_key).decode()
+
+    def decrypt_private_key(self, encrypted_private_key: str) -> str:
+        """Decrypt the private key using the password."""
+        # Decode the base64-encoded data
+        data = base64.b64decode(encrypted_private_key)
+
+        # Extract the salt, IV, and the encrypted private key from the data
+        salt = data[:SALT_LENGTH]
+        iv = data[SALT_LENGTH:SALT_LENGTH + 16]
+        encrypted_data = data[SALT_LENGTH + 16:]
+
+        # Derive the key from the password and salt
+        key = self.derive_key(salt)
+
+        # Create AES cipher
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+        decryptor = cipher.decryptor()
+
+        # Decrypt the private key
+        decrypted_data = decryptor.update(encrypted_data) + decryptor.finalize()
+
+        # Unpad the decrypted data
+        unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
+        private_key = unpadder.update(decrypted_data) + unpadder.finalize()
+
+        return private_key.decode()
+    
+    def extract_address_from_private_key(self, private_key: str) -> str:
+        """
+        Extract the Ethereum address from a given private key.
+
+        Args:
+            private_key (str): The Ethereum private key in hexadecimal format (without the "0x" prefix).
+
+        Returns:
+            str: The Ethereum address derived from the private key.
+        """
+        #w3 = Web3(Web3.HTTPProvider(config.read("NETWORK_RPC")))
+
+
+        # Ensure the private key is in the correct format
+        if not private_key.startswith('0x'):
+            private_key = '0x' + private_key
+
+        # Use the private key to get the account and address
+        account = Account().from_key(private_key)
+
+        return account.address
+
+# Example usage
+#password = "mySecurePassword123"
+#private_key = "77d6DDD127fe3a2bb79df2a02f0f408339"
+
+# Create an instance of PrivateKeyManager
+#key_manager = PrivateKeyManager(password)
+
+# Encrypt the private key
+#encrypted_key = key_manager.encrypt_private_key(private_key)
+#print(f"Encrypted Private Key: {encrypted_key}")
+
+# Decrypt the private key (this will prompt for the password)
+#decrypted_key = key_manager.decrypt_private_key(encrypted_key)
+#print(f"Decrypted Private Key: {decrypted_key}")