Update app.py

app.py

@@ -1,117 +1,54 @@
 import streamlit as st
-import os
 import secrets
 import hashlib
-import tempfile
+import os
 import subprocess
 import json
 from starknet_py.net.account.account import Account
 from starknet_py.net.models import StarknetChainId
 from starknet_py.net.signer.stark_curve_signer import KeyPair
-from starknet_py.net.gateway_client import GatewayClient
-from starknet_py.contract import Contract
 
-# Set page config
 st.set_page_config(
-    page_title="StarkNet 開發工作流程",
+    page_title="StarkNet Development Toolkit",
     page_icon="🌟",
     layout="wide"
 )
 
-# Application title
-st.title("StarkNet 開發完整工作流程")
-st.markdown("""
-這個應用演示了進行 StarkNet 開發的完整流程，包括：
-1. 編寫和編譯 Cairo 合約
-2. 生成 StarkNet 密鑰對和地址
-3. 與 StarkNet 進行交互
-""")
+st.title("StarkNet Development Toolkit")
+st.markdown("A complete workflow for StarkNet development including contract compilation, key generation, and more.")
 
-# Sidebar
-st.sidebar.header("StarkNet 開發工具")
-selected_section = st.sidebar.radio(
-    "選擇步驟",
-    ["編寫和編譯合約", "生成密鑰對和地址", "與 StarkNet 交互"]
-)
+# Sidebar for navigation
+st.sidebar.title("Navigation")
+page = st.sidebar.radio("Choose a step:", [
+    "1. Introduction",
+    "2. Write & Compile Contract",
+    "3. Generate Keys",
+    "4. Interact with StarkNet"
+])
 
-# Function to compile Cairo contract
-def compile_cairo_contract(cairo_code):
-    with tempfile.NamedTemporaryFile(suffix='.cairo', delete=False) as tmp_file:
-        tmp_file.write(cairo_code.encode())
-        tmp_file_path = tmp_file.name
-    
-    output_file = f"{tmp_file_path}_compiled.json"
-    
-    try:
-        result = subprocess.run(
-            ["cairo-compile", tmp_file_path, "--output", output_file],
-            capture_output=True,
-            text=True,
-            check=True
-        )
-        
-        # Read compiled contract
-        with open(output_file, 'r') as f:
-            compiled_contract = json.load(f)
-            
-        # Clean up temporary files
-        os.remove(tmp_file_path)
-        os.remove(output_file)
-        
-        return compiled_contract, result.stdout
-    except subprocess.CalledProcessError as e:
-        return None, e.stderr
-    except Exception as e:
-        return None, str(e)
-
-# Function to generate StarkNet keys
-def generate_starknet_keys():
-    # Generate random private key (251 bits for StarkNet)
-    private_key = secrets.randbits(251)
-    private_key_hex = hex(private_key)
-    
-    # Create key pair
-    key_pair = KeyPair.from_private_key(private_key)
-    
-    # Get public key
-    public_key = key_pair.public_key
-    public_key_hex = hex(public_key)
-    
-    # Try to get an appropriate chain ID
-    try:
-        chain_id = StarknetChainId.GOERLI
-    except AttributeError:
-        try:
-            chain_id = StarknetChainId.SEPOLIA
-        except AttributeError:
-            # Use a generic testnet ID if above networks are not available
-            chain_id = 1536727068981429685321
+# Page 1: Introduction
+if page == "1. Introduction":
+    st.header("Introduction to StarkNet Development")
+    st.write("""
+    StarkNet is a permissionless decentralized ZK-Rollup operating as an L2 network over Ethereum.
+    This application helps you with the full development workflow:
     
-    # Create account object
-    account = Account(
-        address=0,  # Will be populated after deployment
-        client=None,  # Not needed for this example
-        key_pair=key_pair,
-        chain=chain_id
-    )
+    1. **Write and compile Cairo contracts** - Create smart contracts with Cairo language
+    2. **Generate key pairs and addresses** - Create cryptographic keys for StarkNet
+    3. **Interact with StarkNet** - Deploy contracts and interact with the network
     
-    # Get account address
-    address = account.address
+    Use the sidebar to navigate through different steps of the workflow.
+    """)
     
-    return {
-        "private_key": private_key_hex,
-        "public_key": public_key_hex,
-        "address": hex(address),
-        "chain_id": chain_id,
-        "key_pair": key_pair
-    }
+    st.info("This is a development tool. For production use, please ensure proper security measures.")
 
-# Section 1: Write and Compile Cairo Contract
-if selected_section == "編寫和編譯合約":
-    st.header("1. 編寫和編譯 Cairo 合約")
+# Page 2: Write & Compile Contract
+elif page == "2. Write & Compile Contract":
+    st.header("Write & Compile Cairo Contract")
     
-    # Default Cairo contract template
-    default_cairo_code = """%lang cairo
+    # Default example contract
+    default_contract = """
+%lang cairo
 
 @external
 func transfer{syscall_ptr: felt*, range_check_ptr}(
@@ -119,177 +56,227 @@ func transfer{syscall_ptr: felt*, range_check_ptr}(
     to_address: felt,
     amount: felt
 ) -> (success: felt):
-    # 這只是一個簡單的模擬轉帳函數
-    # 在實際應用中，���需要進行餘額檢查和狀態更新
-    return (1)  # 返回成功
+    # This is just a simple simulated transfer function
+    # In a real application, you would need to perform balance checks and state updates
+    return (1)  # Return success
 end
 
 @view
 func get_balance{syscall_ptr: felt*, range_check_ptr}(
     address: felt
 ) -> (balance: felt):
-    # 這只是一個簡單的模擬餘額查詢函數
-    # 在實際應用中，您需要從存儲中讀取真實的餘額
-    return (1000)  # 返回模擬餘額
+    # This is just a simple simulated balance query function
+    # In a real application, you would read the actual balance from storage
+    return (1000)  # Return simulated balance
 end
 """
     
-    cairo_code = st.text_area("Cairo 合約代碼", default_cairo_code, height=400)
+    # Contract editor
+    st.subheader("Contract Editor")
+    contract_code = st.text_area("Edit your Cairo contract:", default_contract, height=400)
     
-    if st.button("編譯合約"):
-        with st.spinner("正在編譯 Cairo 合約..."):
-            compiled_contract, output = compile_cairo_contract(cairo_code)
+    # Compile button
+    if st.button("Compile Contract"):
+        try:
+            # Save the contract to a file
+            with open('token_contract.cairo', 'w') as file:
+                file.write(contract_code)
             
-            if compiled_contract:
-                st.success("合約編譯成功！")
-                st.code(json.dumps(compiled_contract, indent=2), language="json")
+            # Run the compilation command
+            with st.spinner("Compiling..."):
+                result = subprocess.run(
+                    ["cairo-compile", "token_contract.cairo", "--output", "token_compiled.json"],
+                    capture_output=True,
+                    text=True
+                )
+            
+            if result.returncode == 0:
+                st.success("Contract compiled successfully!")
+                
+                # Display compilation output
+                with open("token_compiled.json", "r") as f:
+                    compiled_json = json.load(f)
                 
-                # Save the compiled contract to session state for later use
-                st.session_state['compiled_contract'] = compiled_contract
+                # Allow downloading the compiled contract
+                st.download_button(
+                    label="Download Compiled Contract",
+                    data=json.dumps(compiled_json, indent=2),
+                    file_name="token_compiled.json",
+                    mime="application/json"
+                )
             else:
-                st.error("合約編譯失敗！")
-                st.code(output)
+                st.error(f"Compilation failed: {result.stderr}")
+        except Exception as e:
+            st.error(f"Error during compilation: {str(e)}")
 
-# Section 2: Generate StarkNet Keys
-elif selected_section == "生成密鑰對和地址":
-    st.header("2. 生成 StarkNet 密鑰對和地址")
+# Page 3: Generate Keys
+elif page == "3. Generate Keys":
+    st.header("Generate StarkNet Keys")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Key Generation")
+        
+        # Network selection
+        st.write("Select StarkNet Network:")
+        network_options = {
+            "Goerli Testnet": "GOERLI",
+            "Sepolia Testnet": "SEPOLIA",
+            "Mainnet": "MAINNET",
+            "Custom": "CUSTOM"
+        }
+        network = st.selectbox("Network", list(network_options.keys()))
+        
+        if network == "Custom":
+            chain_id_value = st.number_input("Enter Chain ID value:", value=1536727068981429685321)
+        else:
+            try:
+                chain_id_attr = getattr(StarknetChainId, network_options[network])
+                chain_id_value = chain_id_attr.value
+            except (AttributeError, KeyError):
+                chain_id_value = 1536727068981429685321
+                st.warning(f"Using default chain ID: {chain_id_value}")
+        
+        if st.button("Generate New Keys"):
+            with st.spinner("Generating..."):
+                # Generate a random private key
+                private_key = secrets.randbits(251)
+                private_key_hex = hex(private_key)
+                
+                # Create key pair
+                key_pair = KeyPair.from_private_key(private_key)
+                
+                # Get the public key
+                public_key = key_pair.public_key
+                public_key_hex = hex(public_key)
+                
+                # Create account object
+                account = Account(
+                    address=0,  # Will be populated after deployment
+                    client=None,  # No client needed in this example
+                    key_pair=key_pair,
+                    chain=chain_id_value
+                )
+                
+                # Get the account address
+                address = account.address
+                
+                # Store in session state
+                st.session_state['private_key'] = private_key_hex
+                st.session_state['public_key'] = public_key_hex
+                st.session_state['address'] = hex(address)
+                st.session_state['chain_id'] = chain_id_value
+                
+                st.success("Keys generated successfully!")
     
-    if st.button("生成新的密鑰對"):
-        with st.spinner("正在生成 StarkNet 密鑰..."):
-            keys_info = generate_starknet_keys()
+    with col2:
+        st.subheader("Key Information")
+        
+        if 'private_key' in st.session_state:
+            st.markdown("**Private Key:**")
+            st.code(st.session_state['private_key'])
             
-            # Save keys to session state
-            st.session_state['keys_info'] = keys_info
+            st.markdown("**Public Key:**")
+            st.code(st.session_state['public_key'])
             
-            # Display keys information
-            st.subheader("StarkNet 密鑰信息")
-            st.markdown(f"""
-            - **私鑰**: `{keys_info['private_key']}`
-            - **公鑰**: `{keys_info['public_key']}`
-            - **地址**: `{keys_info['address']}`
-            - **網絡**: `{keys_info['chain_id']}`
-            """)
+            st.markdown("**Address:**")
+            st.code(st.session_state['address'])
             
-            # Option to download keys as text file
-            keys_text = f"""私鑰: {keys_info['private_key']}
-公鑰: {keys_info['public_key']}
-地址: {keys_info['address']}
-網絡: {keys_info['chain_id']}"""
+            st.markdown("**Chain ID:**")
+            st.code(str(st.session_state['chain_id']))
             
+            # Create downloadable key file
+            key_info = f"""Private Key: {st.session_state['private_key']}
+Public Key: {st.session_state['public_key']}
+Address: {st.session_state['address']}
+Chain ID: {st.session_state['chain_id']}
+"""
             st.download_button(
-                label="下載密鑰信息",
-                data=keys_text,
+                label="Download Key Information",
+                data=key_info,
                 file_name="starknet_keys.txt",
                 mime="text/plain"
             )
-    
-    # Display saved keys if available
-    if 'keys_info' in st.session_state:
-        st.subheader("已保存的 StarkNet 密鑰信息")
-        st.markdown(f"""
-        - **私鑰**: `{st.session_state['keys_info']['private_key']}`
-        - **公鑰**: `{st.session_state['keys_info']['public_key']}`
-        - **地址**: `{st.session_state['keys_info']['address']}`
-        - **網絡**: `{st.session_state['keys_info']['chain_id']}`
-        """)
+            
+            st.warning("⚠️ Keep your private key secure! Never share it with anyone.")
+        else:
+            st.info("Generate keys to see the information here.")
 
-# Section 3: Interact with StarkNet
-elif selected_section == "與 StarkNet 交互":
-    st.header("3. 與 StarkNet 交互")
+# Page 4: Interact with StarkNet
+elif page == "4. Interact with StarkNet":
+    st.header("Interact with StarkNet")
     
-    # Network selection
-    network = st.selectbox(
-        "選擇 StarkNet 網絡",
-        ["goerli", "sepolia", "mainnet"]
-    )
-    
-    # Contract address input
-    contract_address = st.text_input("合約地址 (十六進制)", "0x")
+    st.info("""
+    This section provides sample code for interacting with StarkNet.
+    For actual interaction, you would need:
     
-    # Check if we have compiled contract and keys
-    has_contract = 'compiled_contract' in st.session_state
-    has_keys = 'keys_info' in st.session_state
+    1. A deployed contract address
+    2. The contract ABI
+    3. A funded account
     
-    if not has_contract:
-        st.warning("請先在「編寫和編譯合約」步驟中編譯合約")
+    Below is sample code that you can modify for your needs.
+    """)
     
-    if not has_keys:
-        st.warning("請先在「生成密鑰對和地址」步驟中生成密鑰")
-    
-    # Contract interaction section
-    if has_contract and has_keys and st.text_input("合約地址") != "0x":
-        st.subheader("合約交互")
-        
-        # Function selection
-        function_option = st.radio(
-            "選擇函數",
-            ["transfer", "get_balance"]
-        )
-        
-        if function_option == "transfer":
-            # Transfer function parameters
-            st.subheader("轉帳參數")
-            from_address = st.text_input("來源地址", value=st.session_state['keys_info']['address'])
-            to_address = st.text_input("目標地址", "0x")
-            amount = st.number_input("金額", min_value=1, value=100)
-            
-            if st.button("執行轉帳"):
-                st.info("此功能在演示模式下，實際調用需要連接到 StarkNet 網絡")
-                
-                # Here we would implement actual StarkNet interaction
-                st.code(f"""
-# 實際��行代碼將如下:
-client = GatewayClient(net="{network}")
+    interaction_code = """
+# StarkNet Interaction Example
+from starknet_py.net.gateway_client import GatewayClient
+from starknet_py.net.models import StarknetChainId
+from starknet_py.contract import Contract
 
-contract = Contract(
-    address=int("{contract_address}", 16),
-    abi=st.session_state['compiled_contract']['abi'],
-    client=client
-)
+# Set up StarkNet client (using Goerli testnet)
+client = GatewayClient(net="goerli")  # Or "mainnet" for the mainnet
 
-response = await account.execute(
-    calls=[
-        contract.functions["transfer"].prepare(
-            from_address=int("{from_address}", 16),
-            to_address=int("{to_address}", 16),
-            amount={amount}
-        )
-    ]
-)
-                """, language="python")
-        
-        elif function_option == "get_balance":
-            # Get balance function parameters
-            st.subheader("餘額查詢參數")
-            address = st.text_input("查詢地址", value=st.session_state['keys_info']['address'])
-            
-            if st.button("查詢餘額"):
-                st.info("此功能在演示模式下，實際調用需要連接到 StarkNet 網絡")
-                
-                # Here we would implement actual StarkNet interaction
-                st.code(f"""
-# 實際執行代碼將如下:
-client = GatewayClient(net="{network}")
+# Replace with your contract's address and ABI
+contract_address = 0x123456789  # Replace with the real contract address
+contract_abi = [...]  # Contract's ABI, typically obtained from compilation output
 
+# Load the deployed contract
 contract = Contract(
-    address=int("{contract_address}", 16),
-    abi=st.session_state['compiled_contract']['abi'],
-    client=client
+    address=contract_address,
+    abi=contract_abi,
+    client=client,
 )
 
-balance = await contract.functions["get_balance"].call(
-    address=int("{address}", 16)
+# Replace with your account information
+private_key = "YOUR_PRIVATE_KEY"
+key_pair = KeyPair.from_private_key(int(private_key, 16))
+account = Account(
+    address=0x...,  # Your account address
+    client=client,
+    key_pair=key_pair,
+    chain=StarknetChainId.GOERLI
 )
-                """, language="python")
-                
-                # Show a mock result
-                st.success("模擬結果: 餘額 = 1000")
 
-# Footer
-st.markdown("---")
-st.markdown("### StarkNet 開發資源")
-st.markdown("""
-- [StarkNet 官方文檔](https://docs.starknet.io)
-- [Cairo 語言文檔](https://cairo-lang.org)
-- [StarkNet-py 庫文檔](https://github.com/software-mansion/starknet.py)
-""")
+# Example: Call a contract function
+async def transfer_tokens():
+    response = await account.execute(
+        calls=[
+            contract.functions["transfer"].prepare(
+                from_address=account.address,
+                to_address=0x987654321,  # Receiver address
+                amount=100
+            )
+        ]
+    )
+    print(f"Transaction hash: {response.transaction_hash}")
+
+# Example: Query contract state
+async def check_balance(address):
+    balance = await contract.functions["get_balance"].call(
+        address=address
+    )
+    print(f"Balance: {balance.balance}")
+"""
+    
+    st.code(interaction_code, language="python")
+    
+    st.subheader("Resources")
+    st.markdown("""
+    - [StarkNet Documentation](https://docs.starknet.io/)
+    - [Cairo Programming Language](https://cairo-lang.org/)
+    - [starknet-py Library](https://github.com/software-mansion/starknet.py)
+    """)
+
+st.sidebar.markdown("---")
+st.sidebar.info("This application is for educational purposes. Always follow best security practices when working with cryptographic keys.")