opengradient 0.4.6__py3-none-any.whl → 0.4.8__py3-none-any.whl

opengradient/client.py

@@ -2,12 +2,10 @@ import json
 import logging
 import os
 import time
-import uuid
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union
 
 import firebase
-import grpc
 import numpy as np
 import requests
 from eth_account.account import LocalAccount
@@ -15,11 +13,23 @@ from web3 import Web3
 from web3.exceptions import ContractLogicError
 from web3.logs import DISCARD
 
-from . import utils
 from .exceptions import OpenGradientError
 from .proto import infer_pb2, infer_pb2_grpc
-from .types import LLM, TEE_LLM, HistoricalInputQuery, InferenceMode, LlmInferenceMode, ModelOutput, TextGenerationOutput, SchedulerParams
-from .defaults import DEFAULT_IMAGE_GEN_HOST, DEFAULT_IMAGE_GEN_PORT
+from .types import (
+    LLM,
+    TEE_LLM,
+    HistoricalInputQuery,
+    InferenceMode,
+    LlmInferenceMode,
+    ModelOutput,
+    TextGenerationOutput,
+    SchedulerParams,
+    InferenceResult,
+    ModelRepository,
+    FileUploadResult,
+)
+from .defaults import DEFAULT_IMAGE_GEN_HOST, DEFAULT_IMAGE_GEN_PORT, DEFAULT_SCHEDULER_ADDRESS
+from .utils import convert_array_to_model_output, convert_to_model_input, convert_to_model_output
 
 _FIREBASE_CONFIG = {
     "apiKey": "AIzaSyDUVckVtfl-hiteBzPopy1pDD8Uvfncs7w",
@@ -45,10 +55,10 @@ class Client:
     _blockchain: Web3
     _wallet_account: LocalAccount
 
-    _hub_user: Dict
+    _hub_user: Optional[Dict]
     _inference_abi: Dict
 
-    def __init__(self, private_key: str, rpc_url: str, contract_address: str, email: str, password: str):
+    def __init__(self, private_key: str, rpc_url: str, contract_address: str, email: Optional[str], password: Optional[str]):
         """
         Initialize the Client with private key, RPC URL, and contract address.
 
@@ -80,7 +90,7 @@ class Client:
             logging.error(f"Authentication failed: {str(e)}")
             raise
 
-    def create_model(self, model_name: str, model_desc: str, version: str = "1.00") -> dict:
+    def create_model(self, model_name: str, model_desc: str, version: str = "1.00") -> ModelRepository:
         """
         Create a new model with the given model_name and model_desc, and a specified version.
 
@@ -103,41 +113,24 @@ class Client:
         payload = {"name": model_name, "description": model_desc}
 
         try:
-            logging.debug(f"Create Model URL: {url}")
-            logging.debug(f"Headers: {headers}")
-            logging.debug(f"Payload: {payload}")
-
             response = requests.post(url, json=payload, headers=headers)
             response.raise_for_status()
+        except requests.HTTPError as e:
+            error_details = f"HTTP {e.response.status_code}: {e.response.text}"
+            raise OpenGradientError(f"Model creation failed: {error_details}") from e
 
-            json_response = response.json()
-            model_name = json_response.get("name")
-            if not model_name:
-                raise Exception(f"Model creation response missing 'name'. Full response: {json_response}")
-            logging.info(f"Model creation successful. Model name: {model_name}")
+        json_response = response.json()
+        model_name = json_response.get("name")
+        if not model_name:
+            raise Exception(f"Model creation response missing 'name'. Full response: {json_response}")
 
-            # Create the specified version for the newly created model
-            try:
-                version_response = self.create_version(model_name, version)
-                logging.info(f"Version creation successful. Version string: {version_response['versionString']}")
-            except Exception as ve:
-                logging.error(f"Version creation failed, but model was created. Error: {str(ve)}")
-                return {"name": model_name, "versionString": None, "version_error": str(ve)}
+        # Create the specified version for the newly created model
+        version_response = self.create_version(model_name, version)
 
-            return {"name": model_name, "versionString": version_response["versionString"]}
+        return ModelRepository(model_name, version_response["versionString"])
 
-        except requests.RequestException as e:
-            logging.error(f"Model creation failed: {str(e)}")
-            if hasattr(e, "response") and e.response is not None:
-                logging.error(f"Response status code: {e.response.status_code}")
-                logging.error(f"Response headers: {e.response.headers}")
-                logging.error(f"Response content: {e.response.text}")
-            raise Exception(f"Model creation failed: {str(e)}")
-        except Exception as e:
-            logging.error(f"Unexpected error during model creation: {str(e)}")
-            raise
 
-    def create_version(self, model_name: str, notes: str = None, is_major: bool = False) -> dict:
+    def create_version(self, model_name: str, notes: str = "", is_major: bool = False) -> dict:
         """
         Create a new version for the specified model.
 
@@ -196,7 +189,7 @@ class Client:
             logging.error(f"Unexpected error during version creation: {str(e)}")
             raise
 
-    def upload(self, model_path: str, model_name: str, version: str) -> dict:
+    def upload(self, model_path: str, model_name: str, version: str) -> FileUploadResult:
         """
         Upload a model file to the server.
 
@@ -251,12 +244,9 @@ class Client:
                 if response.status_code == 201:
                     if response.content and response.content != b"null":
                         json_response = response.json()
-                        logging.info(f"JSON response: {json_response}")  # Log the parsed JSON response
-                        logging.info(f"Upload successful. CID: {json_response.get('ipfsCid', 'N/A')}")
-                        result = {"model_cid": json_response.get("ipfsCid"), "size": json_response.get("size")}
+                        return FileUploadResult(json_response.get("ipfsCid"), json_response.get("size"))
                     else:
-                        logging.warning("Empty or null response content received. Assuming upload was successful.")
-                        result = {"model_cid": None, "size": None}
+                        raise RuntimeError("Empty or null response content received. Assuming upload was successful.")
                 elif response.status_code == 500:
                     error_message = "Internal server error occurred. Please try again later or contact support."
                     logging.error(error_message)
@@ -266,16 +256,12 @@ class Client:
                     logging.error(f"Upload failed with status code {response.status_code}: {error_message}")
                     raise OpenGradientError(f"Upload failed: {error_message}", status_code=response.status_code)
 
-                return result
-
         except requests.RequestException as e:
             logging.error(f"Request exception during upload: {str(e)}")
             if hasattr(e, "response") and e.response is not None:
                 logging.error(f"Response status code: {e.response.status_code}")
                 logging.error(f"Response content: {e.response.text[:1000]}...")  # Log first 1000 characters
-            raise OpenGradientError(
-                f"Upload failed due to request exception: {str(e)}", status_code=e.response.status_code if hasattr(e, "response") else None
-            )
+            raise OpenGradientError(f"Upload failed due to request exception: {str(e)}")
         except Exception as e:
             logging.error(f"Unexpected error during upload: {str(e)}", exc_info=True)
             raise OpenGradientError(f"Unexpected error during upload: {str(e)}")
@@ -286,7 +272,7 @@ class Client:
         inference_mode: InferenceMode,
         model_input: Dict[str, Union[str, int, float, List, np.ndarray]],
         max_retries: Optional[int] = None,
-    ) -> Tuple[str, Dict[str, np.ndarray]]:
+    ) -> InferenceResult:
         """
         Perform inference on a model.
 
@@ -297,7 +283,7 @@ class Client:
             max_retries (int, optional): Maximum number of retry attempts. Defaults to 5.
 
         Returns:
-            Tuple[str, Dict[str, np.ndarray]]: The transaction hash and the model output.
+            InferenceResult: The transaction hash and the model output.
 
         Raises:
             OpenGradientError: If the inference fails.
@@ -306,8 +292,8 @@ class Client:
         def execute_transaction():
             contract = self._blockchain.eth.contract(address=self._inference_hub_contract_address, abi=self._inference_abi)
 
-            inference_mode_uint8 = int(inference_mode)
-            converted_model_input = utils.convert_to_model_input(model_input)
+            inference_mode_uint8 = inference_mode.value
+            converted_model_input = convert_to_model_input(model_input)
 
             run_function = contract.functions.run(model_cid, inference_mode_uint8, converted_model_input)
 
@@ -336,15 +322,16 @@ class Client:
                 raise OpenGradientError("InferenceResult event not found in transaction logs")
 
             # TODO: This should return a ModelOutput class object
-            model_output = utils.convert_to_model_output(parsed_logs[0]["args"])
-            return tx_hash.hex(), model_output
+            model_output = convert_to_model_output(parsed_logs[0]["args"])
+
+            return InferenceResult(tx_hash.hex(), model_output)
 
         return run_with_retry(execute_transaction, max_retries)
 
     def llm_completion(
         self,
         model_cid: LLM,
-        inference_mode: InferenceMode,
+        inference_mode: LlmInferenceMode,
         prompt: str,
         max_tokens: int = 100,
         stop_sequence: Optional[List[str]] = None,
@@ -383,7 +370,7 @@ class Client:
 
             # Prepare LLM input
             llm_request = {
-                "mode": inference_mode,
+                "mode": inference_mode.value,
                 "modelCID": model_cid,
                 "prompt": prompt,
                 "max_tokens": max_tokens,
@@ -420,18 +407,15 @@ class Client:
                 raise OpenGradientError("LLM completion result event not found in transaction logs")
 
             llm_answer = parsed_logs[0]["args"]["response"]["answer"]
-            
-            return TextGenerationOutput(
-                transaction_hash=tx_hash.hex(),
-                completion_output=llm_answer
-            )
+
+            return TextGenerationOutput(transaction_hash=tx_hash.hex(), completion_output=llm_answer)
 
         return run_with_retry(execute_transaction, max_retries)
 
     def llm_chat(
         self,
         model_cid: LLM,
-        inference_mode: InferenceMode,
+        inference_mode: LlmInferenceMode,
         messages: List[Dict],
         max_tokens: int = 100,
         stop_sequence: Optional[List[str]] = None,
@@ -536,7 +520,7 @@ class Client:
 
             # Prepare LLM input
             llm_request = {
-                "mode": inference_mode,
+                "mode": inference_mode.value,
                 "modelCID": model_cid,
                 "messages": messages,
                 "max_tokens": max_tokens,
@@ -624,234 +608,269 @@ class Client:
             if hasattr(e, "response") and e.response is not None:
                 logging.error(f"Response status code: {e.response.status_code}")
                 logging.error(f"Response content: {e.response.text[:1000]}...")  # Log first 1000 characters
-            raise OpenGradientError(
-                f"File listing failed: {str(e)}", status_code=e.response.status_code if hasattr(e, "response") else None
-            )
+            raise OpenGradientError(f"File listing failed: {str(e)}")
         except Exception as e:
             logging.error(f"Unexpected error during file listing: {str(e)}", exc_info=True)
             raise OpenGradientError(f"Unexpected error during file listing: {str(e)}")
 
-    def generate_image(
-        self,
-        model_cid: str,
-        prompt: str,
-        host: str = DEFAULT_IMAGE_GEN_HOST,
-        port: int = DEFAULT_IMAGE_GEN_PORT,
-        width: int = 1024,
-        height: int = 1024,
-        timeout: int = 300,  # 5 minute timeout
-        max_retries: int = 3,
-    ) -> bytes:
+    # def generate_image(
+    #     self,
+    #     model_cid: str,
+    #     prompt: str,
+    #     host: str = DEFAULT_IMAGE_GEN_HOST,
+    #     port: int = DEFAULT_IMAGE_GEN_PORT,
+    #     width: int = 1024,
+    #     height: int = 1024,
+    #     timeout: int = 300,  # 5 minute timeout
+    #     max_retries: int = 3,
+    # ) -> bytes:
+    #     """
+    #     Generate an image using a diffusion model through gRPC.
+
+    #     Args:
+    #         model_cid (str): The model identifier (e.g. "stabilityai/stable-diffusion-xl-base-1.0")
+    #         prompt (str): The text prompt to generate the image from
+    #         host (str, optional): gRPC host address. Defaults to DEFAULT_IMAGE_GEN_HOST.
+    #         port (int, optional): gRPC port number. Defaults to DEFAULT_IMAGE_GEN_PORT.
+    #         width (int, optional): Output image width. Defaults to 1024.
+    #         height (int, optional): Output image height. Defaults to 1024.
+    #         timeout (int, optional): Maximum time to wait for generation in seconds. Defaults to 300.
+    #         max_retries (int, optional): Maximum number of retry attempts. Defaults to 3.
+
+    #     Returns:
+    #         bytes: The raw image data bytes
+
+    #     Raises:
+    #         OpenGradientError: If the image generation fails
+    #         TimeoutError: If the generation exceeds the timeout period
+    #     """
+
+    #     def exponential_backoff(attempt: int, max_delay: float = 30.0) -> None:
+    #         """Calculate and sleep for exponential backoff duration"""
+    #         delay = min(0.1 * (2**attempt), max_delay)
+    #         time.sleep(delay)
+
+    #     channel = None
+    #     start_time = time.time()
+    #     retry_count = 0
+
+    #     try:
+    #         while retry_count < max_retries:
+    #             try:
+    #                 # Initialize gRPC channel and stub
+    #                 channel = grpc.insecure_channel(f"{host}:{port}")
+    #                 stub = infer_pb2_grpc.InferenceServiceStub(channel)
+
+    #                 # Create image generation request
+    #                 image_request = infer_pb2.ImageGenerationRequest(model=model_cid, prompt=prompt, height=height, width=width)
+
+    #                 # Create inference request with random transaction ID
+    #                 tx_id = str(uuid.uuid4())
+    #                 request = infer_pb2.InferenceRequest(tx=tx_id, image_generation=image_request)
+
+    #                 # Send request with timeout
+    #                 response_id = stub.RunInferenceAsync(
+    #                     request,
+    #                     timeout=min(30, timeout),  # Initial request timeout
+    #                 )
+
+    #                 # Poll for completion
+    #                 attempt = 0
+    #                 while True:
+    #                     # Check timeout
+    #                     if time.time() - start_time > timeout:
+    #                         raise TimeoutError(f"Image generation timed out after {timeout} seconds")
+
+    #                     status_request = infer_pb2.InferenceTxId(id=response_id.id)
+    #                     try:
+    #                         status = stub.GetInferenceStatus(
+    #                             status_request,
+    #                             timeout=min(5, timeout),  # Status check timeout
+    #                         ).status
+    #                     except grpc.RpcError as e:
+    #                         logging.warning(f"Status check failed (attempt {attempt}): {str(e)}")
+    #                         exponential_backoff(attempt)
+    #                         attempt += 1
+    #                         continue
+
+    #                     if status == infer_pb2.InferenceStatus.STATUS_COMPLETED:
+    #                         break
+    #                     elif status == infer_pb2.InferenceStatus.STATUS_ERROR:
+    #                         raise OpenGradientError("Image generation failed on server")
+    #                     elif status != infer_pb2.InferenceStatus.STATUS_IN_PROGRESS:
+    #                         raise OpenGradientError(f"Unexpected status: {status}")
+
+    #                     exponential_backoff(attempt)
+    #                     attempt += 1
+
+    #                 # Get result
+    #                 result = stub.GetInferenceResult(
+    #                     response_id,
+    #                     timeout=min(30, timeout),  # Result fetch timeout
+    #                 )
+    #                 return result.image_generation_result.image_data
+
+    #             except (grpc.RpcError, TimeoutError) as e:
+    #                 retry_count += 1
+    #                 if retry_count >= max_retries:
+    #                     raise OpenGradientError(f"Image generation failed after {max_retries} retries: {str(e)}")
+
+    #                 logging.warning(f"Attempt {retry_count} failed: {str(e)}. Retrying...")
+    #                 exponential_backoff(retry_count)
+
+    #     except grpc.RpcError as e:
+    #         logging.error(f"gRPC error: {str(e)}")
+    #         raise OpenGradientError(f"Image generation failed: {str(e)}")
+    #     except TimeoutError as e:
+    #         logging.error(f"Timeout error: {str(e)}")
+    #         raise
+    #     except Exception as e:
+    #         logging.error(f"Error in generate image method: {str(e)}", exc_info=True)
+    #         raise OpenGradientError(f"Image generation failed: {str(e)}")
+    #     finally:
+    #         if channel:
+    #             channel.close()
+
+    def _get_abi(self, abi_name) -> str:
         """
-        Generate an image using a diffusion model through gRPC.
-
-        Args:
-            model_cid (str): The model identifier (e.g. "stabilityai/stable-diffusion-xl-base-1.0")
-            prompt (str): The text prompt to generate the image from
-            host (str, optional): gRPC host address. Defaults to DEFAULT_IMAGE_GEN_HOST.
-            port (int, optional): gRPC port number. Defaults to DEFAULT_IMAGE_GEN_PORT.
-            width (int, optional): Output image width. Defaults to 1024.
-            height (int, optional): Output image height. Defaults to 1024.
-            timeout (int, optional): Maximum time to wait for generation in seconds. Defaults to 300.
-            max_retries (int, optional): Maximum number of retry attempts. Defaults to 3.
-
-        Returns:
-            bytes: The raw image data bytes
-
-        Raises:
-            OpenGradientError: If the image generation fails
-            TimeoutError: If the generation exceeds the timeout period
+        Returns the ABI for the requested contract.
         """
+        abi_path = Path(__file__).parent / "abi" / abi_name
+        with open(abi_path, "r") as f:
+            return json.load(f)
 
-        def exponential_backoff(attempt: int, max_delay: float = 30.0) -> None:
-            """Calculate and sleep for exponential backoff duration"""
-            delay = min(0.1 * (2**attempt), max_delay)
-            time.sleep(delay)
-
-        channel = None
-        start_time = time.time()
-        retry_count = 0
-
-        try:
-            while retry_count < max_retries:
-                try:
-                    # Initialize gRPC channel and stub
-                    channel = grpc.insecure_channel(f"{host}:{port}")
-                    stub = infer_pb2_grpc.InferenceServiceStub(channel)
-
-                    # Create image generation request
-                    image_request = infer_pb2.ImageGenerationRequest(model=model_cid, prompt=prompt, height=height, width=width)
-
-                    # Create inference request with random transaction ID
-                    tx_id = str(uuid.uuid4())
-                    request = infer_pb2.InferenceRequest(tx=tx_id, image_generation=image_request)
-
-                    # Send request with timeout
-                    response_id = stub.RunInferenceAsync(
-                        request,
-                        timeout=min(30, timeout),  # Initial request timeout
-                    )
-
-                    # Poll for completion
-                    attempt = 0
-                    while True:
-                        # Check timeout
-                        if time.time() - start_time > timeout:
-                            raise TimeoutError(f"Image generation timed out after {timeout} seconds")
-
-                        status_request = infer_pb2.InferenceTxId(id=response_id.id)
-                        try:
-                            status = stub.GetInferenceStatus(
-                                status_request,
-                                timeout=min(5, timeout),  # Status check timeout
-                            ).status
-                        except grpc.RpcError as e:
-                            logging.warning(f"Status check failed (attempt {attempt}): {str(e)}")
-                            exponential_backoff(attempt)
-                            attempt += 1
-                            continue
-
-                        if status == infer_pb2.InferenceStatus.STATUS_COMPLETED:
-                            break
-                        elif status == infer_pb2.InferenceStatus.STATUS_ERROR:
-                            raise OpenGradientError("Image generation failed on server")
-                        elif status != infer_pb2.InferenceStatus.STATUS_IN_PROGRESS:
-                            raise OpenGradientError(f"Unexpected status: {status}")
-
-                        exponential_backoff(attempt)
-                        attempt += 1
-
-                    # Get result
-                    result = stub.GetInferenceResult(
-                        response_id,
-                        timeout=min(30, timeout),  # Result fetch timeout
-                    )
-                    return result.image_generation_result.image_data
-
-                except (grpc.RpcError, TimeoutError) as e:
-                    retry_count += 1
-                    if retry_count >= max_retries:
-                        raise OpenGradientError(f"Image generation failed after {max_retries} retries: {str(e)}")
-
-                    logging.warning(f"Attempt {retry_count} failed: {str(e)}. Retrying...")
-                    exponential_backoff(retry_count)
-
-        except grpc.RpcError as e:
-            logging.error(f"gRPC error: {str(e)}")
-            raise OpenGradientError(f"Image generation failed: {str(e)}")
-        except TimeoutError as e:
-            logging.error(f"Timeout error: {str(e)}")
-            raise
-        except Exception as e:
-            logging.error(f"Error in generate image method: {str(e)}", exc_info=True)
-            raise OpenGradientError(f"Image generation failed: {str(e)}")
-        finally:
-            if channel:
-                channel.close()
-
-    def _get_model_executor_abi(self) -> List[Dict]:
+    def _get_bin(self, bin_name) -> str:
         """
-        Returns the ABI for the ModelExecutorHistorical contract.
+        Returns the bin for the requested contract.
         """
-        abi_path = Path(__file__).parent / "abi" / "ModelExecutorHistorical.abi"
-        with open(abi_path, "r") as f:
-            return json.load(f)
+        bin_path = Path(__file__).parent / "bin" / bin_name
+        # Read bytecode with explicit encoding
+        with open(bin_path, "r", encoding="utf-8") as f:
+            bytecode = f.read().strip()
+            if not bytecode.startswith("0x"):
+                bytecode = "0x" + bytecode
+            return bytecode
 
     def new_workflow(
         self,
         model_cid: str,
-        input_query: Union[Dict[str, Any], HistoricalInputQuery],
+        input_query: HistoricalInputQuery,
         input_tensor_name: str,
         scheduler_params: Optional[SchedulerParams] = None,
     ) -> str:
         """
         Deploy a new workflow contract with the specified parameters.
-        """
-        if isinstance(input_query, dict):
-            input_query = HistoricalInputQuery.from_dict(input_query)
 
-        # Get contract ABI and bytecode
-        abi = self._get_model_executor_abi()
-        bin_path = Path(__file__).parent / "bin" / "ModelExecutorHistorical.bin"
-
-        with open(bin_path, "r") as f:
-            bytecode = f.read().strip()
+        This function deploys a new workflow contract on OpenGradient that connects
+        an AI model with its required input data. When executed, the workflow will fetch
+        the specified model, evaluate the input query to get data, and perform inference.
 
-        print("📦 Deploying workflow contract...")
+        The workflow can be set to execute manually or automatically via a scheduler.
 
-        # Create contract instance
-        contract = self._blockchain.eth.contract(abi=abi, bytecode=bytecode)
+        Args:
+            model_cid (str): CID of the model to be executed from the Model Hub
+            input_query (HistoricalInputQuery): Input definition for the model inference,
+                will be evaluated at runtime for each inference
+            input_tensor_name (str): Name of the input tensor expected by the model
+            scheduler_params (Optional[SchedulerParams]): Scheduler configuration for automated execution:
+                - frequency: Execution frequency in seconds
+                - duration_hours: How long the schedule should live for
 
-        # Deploy contract with constructor arguments
-        transaction = contract.constructor().build_transaction(
-            {
-                "from": self._wallet_account.address,
-                "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
-                "gas": 15000000,
-                "gasPrice": self._blockchain.eth.gas_price,
-                "chainId": self._blockchain.eth.chain_id,
-            }
-        )
+        Returns:
+            str: Deployed contract address. If scheduler_params was provided, the workflow
+                 will be automatically executed according to the specified schedule.
 
-        signed_txn = self._wallet_account.sign_transaction(transaction)
-        tx_hash = self._blockchain.eth.send_raw_transaction(signed_txn.raw_transaction)
-        tx_receipt = self._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=REGULAR_TX_TIMEOUT)
-        contract_address = tx_receipt.contractAddress
+        Raises:
+            Exception: If transaction fails or gas estimation fails
+        """
+        # Get contract ABI and bytecode
+        abi = self._get_abi("PriceHistoryInference.abi")
+        bytecode = self._get_bin("PriceHistoryInference.bin")
 
-        print(f"✅ Workflow contract deployed at: {contract_address}")
+        def deploy_transaction():
+            contract = self._blockchain.eth.contract(abi=abi, bytecode=bytecode)
+            query_tuple = input_query.to_abi_format()
+            constructor_args = [model_cid, input_tensor_name, query_tuple]
 
-        # Register with scheduler if params provided
-        if scheduler_params:
-            print("\n⏰ Setting up automated execution schedule...")
-            print(f"   • Frequency: Every {scheduler_params.frequency} seconds")
-            print(f"   • Duration: {scheduler_params.duration_hours} hours")
-            print(f"   • End Time: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(scheduler_params.end_time))}")
+            try:
+                # Estimate gas needed
+                estimated_gas = contract.constructor(*constructor_args).estimate_gas({"from": self._wallet_account.address})
+                gas_limit = int(estimated_gas * 1.2)
+            except Exception as e:
+                print(f"⚠️ Gas estimation failed: {str(e)}")
+                gas_limit = 5000000  # Conservative fallback
+                print(f"📊 Using fallback gas limit: {gas_limit}")
 
-            scheduler_abi = [
+            transaction = contract.constructor(*constructor_args).build_transaction(
                 {
-                    "inputs": [
-                        {"internalType": "address", "name": "contractAddress", "type": "address"},
-                        {"internalType": "uint256", "name": "endTime", "type": "uint256"},
-                        {"internalType": "uint256", "name": "frequency", "type": "uint256"},
-                    ],
-                    "name": "registerTask",
-                    "outputs": [],
-                    "stateMutability": "nonpayable",
-                    "type": "function",
+                    "from": self._wallet_account.address,
+                    "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
+                    "gas": gas_limit,
+                    "gasPrice": self._blockchain.eth.gas_price,
+                    "chainId": self._blockchain.eth.chain_id,
                 }
-            ]
+            )
 
-            scheduler_address = "0x6F937b9f4Fa7723932827cd73063B70Be2b56748"
-            scheduler_contract = self._blockchain.eth.contract(address=scheduler_address, abi=scheduler_abi)
+            signed_txn = self._wallet_account.sign_transaction(transaction)
+            tx_hash = self._blockchain.eth.send_raw_transaction(signed_txn.raw_transaction)
 
-            try:
-                # Register the workflow with the scheduler
-                scheduler_tx = scheduler_contract.functions.registerTask(
-                    contract_address, scheduler_params.end_time, scheduler_params.frequency
-                ).build_transaction(
-                    {
-                        "from": self._wallet_account.address,
-                        "gas": 300000,
-                        "gasPrice": self._blockchain.eth.gas_price,
-                        "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
-                        "chainId": self._blockchain.eth.chain_id,
-                    }
-                )
+            tx_receipt = self._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
 
-                signed_scheduler_tx = self._wallet_account.sign_transaction(scheduler_tx)
-                scheduler_tx_hash = self._blockchain.eth.send_raw_transaction(signed_scheduler_tx.raw_transaction)
-                self._blockchain.eth.wait_for_transaction_receipt(scheduler_tx_hash, timeout=REGULAR_TX_TIMEOUT)
+            if tx_receipt["status"] == 0:
+                raise Exception(f"❌ Contract deployment failed, transaction hash: {tx_hash.hex()}")
 
-                print("✅ Automated execution schedule set successfully!")
-                print(f"   Transaction hash: {scheduler_tx_hash.hex()}")
+            return tx_receipt.contractAddress
 
-            except Exception as e:
-                print("❌ Failed to set up automated execution schedule")
-                print(f"   Error: {str(e)}")
-                print("   The workflow contract is still deployed and can be executed manually.")
+        contract_address = run_with_retry(deploy_transaction)
+
+        if scheduler_params:
+            self._register_with_scheduler(contract_address, scheduler_params)
 
         return contract_address
 
+    def _register_with_scheduler(self, contract_address: str, scheduler_params: SchedulerParams) -> None:
+        """
+        Register the deployed workflow contract with the scheduler for automated execution.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+            scheduler_params (SchedulerParams): Scheduler configuration containing:
+                - frequency: Execution frequency in seconds
+                - duration_hours: How long to run in hours
+                - end_time: Unix timestamp when scheduling should end
+
+        Raises:
+            Exception: If registration with scheduler fails. The workflow contract will
+                      still be deployed and can be executed manually.
+        """
+
+        scheduler_abi = self._get_abi("WorkflowScheduler.abi")
+
+        # Scheduler contract address
+        scheduler_address = DEFAULT_SCHEDULER_ADDRESS
+        scheduler_contract = self._blockchain.eth.contract(address=scheduler_address, abi=scheduler_abi)
+
+        try:
+            # Register the workflow with the scheduler
+            scheduler_tx = scheduler_contract.functions.registerTask(
+                contract_address, scheduler_params.end_time, scheduler_params.frequency
+            ).build_transaction(
+                {
+                    "from": self._wallet_account.address,
+                    "gas": 300000,
+                    "gasPrice": self._blockchain.eth.gas_price,
+                    "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
+                    "chainId": self._blockchain.eth.chain_id,
+                }
+            )
+
+            signed_scheduler_tx = self._wallet_account.sign_transaction(scheduler_tx)
+            scheduler_tx_hash = self._blockchain.eth.send_raw_transaction(signed_scheduler_tx.raw_transaction)
+            self._blockchain.eth.wait_for_transaction_receipt(scheduler_tx_hash, timeout=REGULAR_TX_TIMEOUT)
+        except Exception as e:
+            print(f"❌ Error registering contract with scheduler: {str(e)}")
+            print("  The workflow contract is still deployed and can be executed manually.")
+
     def read_workflow_result(self, contract_address: str) -> ModelOutput:
         """
         Reads the latest inference result from a deployed workflow contract.
@@ -867,12 +886,14 @@ class Client:
             Web3Error: If there are issues with the web3 connection or contract interaction
         """
         # Get the contract interface
-        contract = self._blockchain.eth.contract(address=Web3.to_checksum_address(contract_address), abi=self._get_model_executor_abi())
+        contract = self._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
 
         # Get the result
         result = contract.functions.getInferenceResult().call()
 
-        return utils.convert_array_to_model_output(result)
+        return convert_array_to_model_output(result)
 
     def run_workflow(self, contract_address: str) -> ModelOutput:
         """
@@ -889,7 +910,9 @@ class Client:
             Web3Error: If there are issues with the web3 connection or contract interaction
         """
         # Get the contract interface
-        contract = self._blockchain.eth.contract(address=Web3.to_checksum_address(contract_address), abi=self._get_model_executor_abi())
+        contract = self._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
 
         # Call run() function
         nonce = self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending")
@@ -915,7 +938,28 @@ class Client:
         # Get the inference result from the contract
         result = contract.functions.getInferenceResult().call()
 
-        return utils.convert_array_to_model_output(result)
+        return convert_array_to_model_output(result)
+
+    def read_workflow_history(self, contract_address: str, num_results: int) -> List[ModelOutput]:
+        """
+        Gets historical inference results from a workflow contract.
+
+        Retrieves the specified number of most recent inference results from the contract's
+        storage, with the most recent result first.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+            num_results (int): Number of historical results to retrieve
+
+        Returns:
+            List[ModelOutput]: List of historical inference results
+        """
+        contract = self._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
+
+        results = contract.functions.getLastInferenceResults(num_results).call()
+        return [convert_array_to_model_output(result) for result in results]
 
 
 def run_with_retry(txn_function, max_retries=DEFAULT_MAX_RETRY, retry_delay=DEFAULT_RETRY_DELAY_SEC):