added smart contract

app.py

@@ -14,6 +14,9 @@ from web3 import Web3
 from eth_tester import EthereumTester
 from web3.providers.eth_tester import EthereumTesterProvider
 from eth_account import Account
+from solcx import compile_source, install_solc
+import solcx
+from eth_utils import to_checksum_address
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -40,6 +43,14 @@ class EthereumClient:
         
         # Initialize with local testnet by default
         self._connect_local_testnet()
+
+        # Install Solidity compiler for contract compilation
+        try:
+            install_solc('0.8.19')
+            solcx.set_solc_version('0.8.19')
+        except Exception as e:
+            logger.warning(f"Could not install Solidity compiler: {e}")
+
         
     def _connect_local_testnet(self):
         """Connect to local test blockchain"""
@@ -179,6 +190,116 @@ class EthereumClient:
             except Exception as e:
                 logger.error(f"Error funding test account: {e}")
 
+    def compile_and_deploy_contract(self, source_code: str, contract_name: str, from_account: str, constructor_args: list = None) -> dict:
+        """
+        Compile and deploy a smart contract.
+        Only works on local testnet for safety.
+        
+        Args:
+            source_code (str): Solidity source code
+            contract_name (str): Name of the contract to deploy
+            from_account (str): Account name to deploy from
+            constructor_args (list): Constructor arguments if any
+            
+        Returns:
+            dict: Deployment result
+        """
+        try:
+            if self.is_mainnet_readonly:
+                return {
+                    "success": False, 
+                    "error": "Contract deployment disabled on mainnet for safety. Switch to testnet."
+                }
+            
+            if self.current_network != "local_testnet":
+                return {
+                    "success": False, 
+                    "error": "Contract deployment only available on local testnet for safety in public deployment"
+                }
+            
+            if from_account not in self.accounts:
+                return {"success": False, "error": "Account not found"}
+            
+            # Compile the contract
+            try:
+                compiled_sol = compile_source(source_code)
+                contract_interface = None
+                
+                # Find the contract in compiled output
+                for contract_id, contract_data in compiled_sol.items():
+                    if contract_name in contract_id:
+                        contract_interface = contract_data
+                        break
+                
+                if not contract_interface:
+                    return {"success": False, "error": f"Contract '{contract_name}' not found in source code"}
+                
+            except Exception as e:
+                return {"success": False, "error": f"Compilation failed: {str(e)}"}
+            
+            # Get account details
+            account_data = self.accounts[from_account]
+            private_key = account_data["private_key"]
+            from_address = account_data["address"]
+            
+            # Create contract instance
+            contract = self.w3.eth.contract(
+                abi=contract_interface['abi'],
+                bytecode=contract_interface['bin']
+            )
+            
+            # Prepare constructor arguments
+            constructor_args = constructor_args or []
+            
+            # Build deployment transaction
+            nonce = self.w3.eth.get_transaction_count(from_address)
+            
+            # Estimate gas for deployment
+            try:
+                gas_estimate = contract.constructor(*constructor_args).estimate_gas({
+                    'from': from_address
+                })
+                # Add 20% buffer to gas estimate
+                gas_limit = int(gas_estimate * 1.2)
+            except Exception as e:
+                gas_limit = 3000000  # Default gas limit
+            
+            # Build and sign transaction
+            transaction = contract.constructor(*constructor_args).build_transaction({
+                'from': from_address,
+                'gas': gas_limit,
+                'gasPrice': self.w3.eth.gas_price,
+                'nonce': nonce,
+            })
+            
+            signed_txn = self.w3.eth.account.sign_transaction(transaction, private_key)
+            tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+            
+            # Wait for transaction receipt
+            tx_receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
+            
+            if tx_receipt.status == 1:
+                return {
+                    "success": True,
+                    "contract_address": tx_receipt.contractAddress,
+                    "transaction_hash": tx_hash.hex(),
+                    "gas_used": tx_receipt.gasUsed,
+                    "contract_name": contract_name,
+                    "deployed_by": from_address,
+                    "network": self.current_network,
+                    "abi": contract_interface['abi']
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "Contract deployment failed",
+                    "transaction_hash": tx_hash.hex()
+                }
+                
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+
 # Initialize the Ethereum client
 config = EthereumConfig(use_testnet=True)
 eth_client = EthereumClient(config)
@@ -343,7 +464,7 @@ def send_ethereum_transaction(from_account: str, to_address: str, amount_eth: fl
         }
         
         signed_txn = eth_client.w3.eth.account.sign_transaction(transaction, private_key)
-        tx_hash = eth_client.w3.eth.send_raw_transaction(signed_txn.rawTransaction)
+        tx_hash = eth_client.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
         
         return {
             "success": True,
@@ -486,6 +607,23 @@ def mine_ethereum_blocks(num_blocks: int = 1) -> dict:
     except Exception as e:
         return {"success": False, "error": str(e)}
 
+def deploy_smart_contract(source_code: str, contract_name: str, from_account: str, constructor_args: list = None) -> dict:
+    """
+    Compile and deploy a smart contract to the blockchain.
+    Note: Only works on local testnet for safety.
+    
+    Args:
+        source_code (str): Solidity source code
+        contract_name (str): Name of the contract to deploy  
+        from_account (str): Name of the account to deploy from
+        constructor_args (list): Constructor arguments if any
+        
+    Returns:
+        dict: Contract deployment result
+    """
+    return eth_client.compile_and_deploy_contract(source_code, contract_name, from_account, constructor_args)
+
+
 # Gradio Interface Functions
 def switch_network_ui(network: str, api_key: str):
     """Gradio wrapper for network switching"""
@@ -553,6 +691,55 @@ def mine_blocks_ui(num_blocks: int):
     result = mine_ethereum_blocks(num_blocks)
     return json.dumps(result, indent=2)
 
+def deploy_contract_ui(source_code: str, contract_name: str, from_account: str, constructor_args_str: str):
+    """Gradio wrapper for contract deployment"""
+    if not source_code or not contract_name or not from_account:
+        return "Please provide source code, contract name, and from account"
+    
+    # Parse constructor arguments if provided
+    constructor_args = []
+    if constructor_args_str.strip():
+        try:
+            # Parse constructor arguments with type conversion
+            args_list = [arg.strip() for arg in constructor_args_str.split(',') if arg.strip()]
+            
+            for arg in args_list:
+                # Try to convert to appropriate types
+                if arg.lower() in ['true', 'false']:
+                    # Boolean
+                    constructor_args.append(arg.lower() == 'true')
+                elif arg.startswith('0x') and len(arg) == 42:
+                    # Ethereum address
+                    constructor_args.append(to_checksum_address(arg))
+                elif arg.startswith('"') and arg.endswith('"'):
+                    # String (remove quotes)
+                    constructor_args.append(arg[1:-1])
+                elif arg.startswith("'") and arg.endswith("'"):
+                    # String (remove quotes)
+                    constructor_args.append(arg[1:-1])
+                elif '.' in arg:
+                    # Float/Decimal - convert to int if it's actually a whole number
+                    try:
+                        float_val = float(arg)
+                        if float_val.is_integer():
+                            constructor_args.append(int(float_val))
+                        else:
+                            constructor_args.append(float_val)
+                    except ValueError:
+                        constructor_args.append(arg)  # Keep as string if conversion fails
+                else:
+                    # Try integer first, then keep as string
+                    try:
+                        constructor_args.append(int(arg))
+                    except ValueError:
+                        constructor_args.append(arg)
+                        
+        except Exception as e:
+            return f"Error parsing constructor arguments: {str(e)}"
+    
+    result = deploy_smart_contract(source_code, contract_name, from_account, constructor_args)
+    return json.dumps(result, indent=2)
+
 # Create Gradio Interface
 def create_gradio_app():
     """Create the Gradio web interface"""
@@ -705,6 +892,78 @@ def create_gradio_app():
                             fn=list_ethereum_accounts,
                             outputs=accounts_json_output
                         )
+            with gr.Tab("📄 Smart Contracts"):
+                gr.Markdown("### Deploy Smart Contracts")
+                gr.Markdown("*⚠️ Only available on local testnet for safety*")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("#### Contract Deployment")
+                        contract_source = gr.Textbox(
+                            label="Solidity Source Code",
+                            placeholder="""pragma solidity ^0.8.19;
+
+contract SimpleStorage {
+    uint256 public storedData;
+    
+    constructor(uint256 _initialValue) {
+        storedData = _initialValue;
+    }
+    
+    function set(uint256 _value) public {
+        storedData = _value;
+    }
+    
+    function get() public view returns (uint256) {
+        return storedData;
+    }
+}""",
+                            lines=15
+                        )
+                        
+                        with gr.Row():
+                            contract_name_input = gr.Textbox(
+                                label="Contract Name", 
+                                placeholder="SimpleStorage"
+                            )
+                            deploy_from_account = gr.Textbox(
+                                label="Deploy From Account", 
+                                placeholder="test_account_1"
+                            )
+                        
+                        constructor_args_input = gr.Textbox(
+                            label="Constructor Arguments (comma-separated)", 
+                            placeholder="100",
+                            info="Examples: 100 (number), \"Hello\" (string), 0x1234...abcd (address), true/false (boolean)"
+                        )
+                        
+                        deploy_btn = gr.Button("Deploy Contract", variant="primary")
+                        deploy_output = gr.Textbox(label="Deployment Result", lines=12)
+                        
+                        deploy_btn.click(
+                            deploy_contract_ui,
+                            inputs=[contract_source, contract_name_input, deploy_from_account, constructor_args_input],
+                            outputs=[deploy_output]
+                        )
+                    
+                    with gr.Column():
+                        gr.Markdown("#### Example Contracts")
+                        gr.Markdown("""
+**Simple Storage Contract:**
+```solidity
+pragma solidity ^0.8.19;
+
+contract SimpleStorage {
+    uint256 public storedData;
+    
+    constructor(uint256 _initialValue) {
+        storedData = _initialValue;
+    }
+    
+    function set(uint256 _value) public {
+        storedData = _value;
+    }
+}""")
         
         gr.Markdown("---")
         gr.Markdown("### 🔒 Safety Features for Public Deployment")
@@ -714,7 +973,7 @@ def create_gradio_app():
         gr.Markdown("- **Transaction Restrictions**: Transactions only available on safe local testnet")
         
         gr.Markdown("### 🤖 MCP Integration")
-        gr.Markdown("**Available MCP Tools**: `switch_ethereum_network`, `get_network_info`, `create_ethereum_account`, `get_ethereum_balance`, `send_ethereum_transaction`, `get_latest_ethereum_block`, `get_transaction_info`, `list_ethereum_accounts`, `mine_ethereum_blocks`")
+        gr.Markdown("**Available MCP Tools**: `switch_ethereum_network`, `get_network_info`, `create_ethereum_account`, `get_ethereum_balance`, `send_ethereum_transaction`, `get_latest_ethereum_block`, `get_transaction_info`, `list_ethereum_accounts`, `mine_ethereum_blocks`, `deploy_smart_contract`")
     
     return app
 

requirements.txt

@@ -9,3 +9,5 @@ web3>=6.15.0
 eth-account>=0.10.0
 eth-tester
 py-evm
+py-solc-x
+eth-utils