Initial deployment commit

Author: AbdulSalam416

.DS_Store

@@ -6,11 +6,13 @@ out/
 !/broadcast
 /broadcast/*/31337/
 /broadcast/**/dry-run/
-
+/client/lib/smartContractFunctions.sol
 # Docs
 docs/
 
 # Dotenv file
 .env
 PRODUCT.md
-ai_trader_npc_fastapi/GEMINI.md
+ai_trader_npc_fastapi/GEMINI.md
+
+ai_trader_npc_fastapi/test_buy_event.py

.gitignore

@@ -0,0 +1 @@
+web: gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app --bind 0.0.0.0:$PORT

ai_trader_npc_fastapi/Procfile

@@ -1,17 +1,11 @@
 import os
 from dotenv import load_dotenv
-from eth_account import Account
 
 load_dotenv()
 
 RPC_URL = os.getenv("RPC_URL")
-WSS_RPC_URL = os.getenv("WSS_RPC_URL") # For event listening
+WSS_RPC_URL = os.getenv("WSS_RPC_URL")
 CONTRACT_ADDRESS = os.getenv("CONTRACT_ADDRESS")
-PRIVATE_KEY = os.getenv("PRIVATE_KEY")
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-
-# Derive owner address from private key
-if PRIVATE_KEY:
-    OWNER_ADDRESS = Account.from_key(PRIVATE_KEY).address
-else:
-    OWNER_ADDRESS = None
+AI_PRIVATE_KEY = os.getenv("AI_PRIVATE_KEY")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+OWNER_ADDRESS = os.getenv("AI_WALLET")

ai_trader_npc_fastapi/api/routes_ai.py

@@ -1,28 +1,19 @@
 import asyncio
 import threading
 from fastapi import FastAPI
-from api.routes_products import router as products_router
-from api.routes_ai import router as ai_router
 from services.event_listener import start_event_listener
 
 app = FastAPI(title="AI Trader NPC API", version="1.0")
 
 def run_event_listener():
-    """Helper function to run the asyncio event listener in a new loop."""
     asyncio.run(start_event_listener())
 
 @app.on_event("startup")
 async def startup_event():
-    """
-    On startup, run the event listener in a separate thread.
-    """
     print("Starting background event listener thread...")
     thread = threading.Thread(target=run_event_listener, daemon=True)
     thread.start()
 
-app.include_router(products_router, prefix="/api/items", tags=["Items"])
-app.include_router(ai_router, prefix="/api/ai", tags=["AI"])
-
 @app.get("/")
 def root():
     return {"message": "AI Trader NPC Backend is running"}

ai_trader_npc_fastapi/api/routes_products.py

@@ -2,5 +2,6 @@ fastapi
 uvicorn
 web3
 python-dotenv
-openai
-eth_account
+google-generativeai
+eth_account
+gunicorn

ai_trader_npc_fastapi/core/config.py

@@ -1,34 +1,31 @@
 import json
-from openai import OpenAI
-from core.config import OPENAI_API_KEY
+import google.generativeai as genai
+from core.config import GEMINI_API_KEY
 
-client = OpenAI(api_key=OPENAI_API_KEY)
+genai.configure(api_key=GEMINI_API_KEY)
 
 def calculate_price_deterministically(base_price, demand_factor, supply_factor):
     """
     Calculates a new price using a deterministic formula based on market factors.
     This function is fast, predictable, and controllable.
     """
     # --- Tunable Weights ---
-    # These can be adjusted to change the trader's behavior.
-    demand_weight = 0.05  # 5% price change per point of demand.
-    supply_weight = 0.04  # 4% price change per point of supply.
+    demand_weight = 0.05
+    supply_weight = 0.04
 
-    # --- Pricing Formula ---
     demand_adjustment = 1.0 + (demand_factor * demand_weight)
     # We use a negative supply_factor to represent supply pressure
     supply_adjustment = 1.0 - (supply_factor * supply_weight)
-
     new_price = base_price * demand_adjustment * supply_adjustment
-    
-    # Ensure price is at least 1
     return max(1, int(new_price))
 
 
 async def get_ai_market_factors(item_name, demand_index, supply):
     """
-    Uses the LLM to analyze market conditions and return structured factors.
+    the LLM to analyze market conditions and return structured factors.
     """
+    model = genai.GenerativeModel('models/gemini-flash-latest')
+
     system_prompt = (
         "You are a master trader in a fantasy world. Your goal is to analyze market data "
         "and provide key factors for a pricing model. Respond only with a valid JSON object."
@@ -44,15 +41,11 @@ async def get_ai_market_factors(item_name, demand_index, supply):
     )
 
     try:
-        response = client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt}
-            ],
-            response_format={"type": "json_object"}
+        response = await model.generate_content_async(
+            [system_prompt, user_prompt],
+            generation_config={"response_mime_type": "application/json"}
         )
-        factors = json.loads(response.choices[0].message.content)
+        factors = json.loads(response.text)
         print(f"AI market analysis for {item_name}: {factors}")
         return factors
 
@@ -63,18 +56,15 @@ async def get_ai_market_factors(item_name, demand_index, supply):
 
 async def get_hybrid_price_suggestion(item_name, base_price, demand_index, supply):
     """
-    Orchestrates the hybrid pricing model.
+    Orchestrates our hybrid pricing model.
     1. Gets market factors from the AI.
     2. Calculates the final price using a deterministic formula.
     """
-    # Step 1: Get market analysis from the LLM
     factors = await get_ai_market_factors(item_name, demand_index, supply)
-    
     if not factors or 'demand_factor' not in factors or 'supply_factor' not in factors:
         print("Could not retrieve valid market factors from AI. Aborting price change.")
         return None
-        
-    # Step 2: Calculate the final price deterministically
+
     new_price = calculate_price_deterministically(
         base_price=base_price,
         demand_factor=factors['demand_factor'],

ai_trader_npc_fastapi/main.py

@@ -29,15 +29,13 @@ async def handle_event(event):
     demand_signals[item_address] = max(0, min(10, demand_signals[item_address]))
     demand_index = demand_signals[item_address]
 
-    # On-chain data
     item_details = await get_item_details(item_address)
     if not item_details:
         return
 
     current_price = item_details["price"]
     current_inventory = item_details["inventory"]
 
-    # AI suggestion
     new_price = await get_hybrid_price_suggestion(
         item_name=item_address,
         base_price=current_price,
@@ -65,17 +63,13 @@ async def start_event_listener():
             async for w3 in AsyncWeb3(WebSocketProvider(WSS_RPC_URL), modules={"eth": (AsyncEth,)}):
                 print("Connected to WebSocket provider!")
 
-                # Load contract ABI
                 with open("../abi/AITrader.json") as f:
                     contract_abi = json.load(f)
 
                 contract = w3.eth.contract(address=CONTRACT_ADDRESS, abi=contract_abi)
-
-                # Create event filters
                 bought_filter = await contract.events.ItemBought.create_filter(from_block="latest")
                 sold_filter = await contract.events.ItemSold.create_filter(from_block="latest")
                 print("Event filters created.")
-                # Poll events
                 while True:
                     for event in await bought_filter.get_new_entries():
                         await handle_event(event)