# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * from genlayer.gl.vm import UserError import json WEB_TRUNCATE = 8000 # Verdict the AI returns when it cannot identify the product OR cannot # determine the listed/typical price with reasonable confidence. This is # distinct from FAIR_PRICE (which means "AI looked and the price is OK"). VERDICT_INSUFFICIENT = "INSUFFICIENT_DATA" ALLOWED_VERDICTS = ("GREAT_DEAL", "FAIR_PRICE", "OVERPRICED", "SCAM_ALERT", VERDICT_INSUFFICIENT) def _smart_search_query(product_url: str) -> str: """Extract a meaningful search query from a product URL. Domain-specific extractors for the big retailers (Amazon, eBay, Walmart, Best Buy, AliExpress) get the human-readable product slug instead of the raw product ID, then fall back to a generic "longest meaningful path segment" heuristic. Numeric/short alphanumeric IDs are skipped because they make terrible search queries (a search for "B0BDHWDR12" gives noise). """ url_lower = product_url.lower() path = product_url.split("?")[0].rstrip("/") parts = [p for p in path.split("/") if p and not p.startswith("http")] def slug_to_words(s: str) -> str: return " ".join( w for w in s.replace("-", " ").replace("_", " ").replace("+", " ").split() if len(w) > 1 and not w.isdigit() ) # Amazon: product slug usually appears just before /dp/ASIN or /gp/product/ if "amazon." in url_lower: for i, p in enumerate(parts): if p in ("dp", "gp") and i > 0: slug = parts[i - 1] words = slug_to_words(slug) if len(words) > 5: return words[:120] # Fall through: use generic path search # eBay: /itm/title-or-id if "ebay." in url_lower: for i, p in enumerate(parts): if p == "itm" and i + 1 < len(parts): words = slug_to_words(parts[i + 1]) if len(words) > 3: return words[:120] # Walmart: /ip/Product-Name/12345 if "walmart." in url_lower: for i, p in enumerate(parts): if p == "ip" and i + 1 < len(parts): words = slug_to_words(parts[i + 1]) if len(words) > 3: return words[:120] # Best Buy: /site/product-name/12345.p if "bestbuy." in url_lower: for i, p in enumerate(parts): if p == "site" and i + 1 < len(parts): words = slug_to_words(parts[i + 1]) if len(words) > 3: return words[:120] # AliExpress: /item/Product-Name/12345.html if "aliexpress." in url_lower: for i, p in enumerate(parts): if p == "item" and i + 1 < len(parts): words = slug_to_words(parts[i + 1]) if len(words) > 3: return words[:120] # Generic: pick the path segment with the most "real words" (skip pure IDs). best = "" for p in parts: words = slug_to_words(p) if len(words.split()) >= 2 and len(words) > len(best): best = words if best: return best[:120] # Last-ditch fallback: the last non-empty path segment, ID or not. last = parts[-1] if parts else "" return slug_to_words(last)[:120] or last[:60] def _looks_like_bot_wall(content: str) -> bool: """Detect when scraped content is a captcha / login wall / DDoS check instead of real product data, so the AI doesn't hallucinate from junk.""" if not content or len(content) < 200: return True low = content.lower() bot_signals = ( "captcha", "are you a robot", "verify you are human", "access denied", "request blocked", "cloudflare", "just a moment", "checking your browser", "sign in to continue", "log in to continue", "enable javascript and cookies", "robot check", ) hits = sum(1 for s in bot_signals if s in low) # 2+ signals = almost certainly a wall; 1 signal in tiny content = same. return hits >= 2 or (hits >= 1 and len(content) < 1500) class PriceGuard(gl.Contract): """ PriceGuard — AI-Powered Price Verification on GenLayer. """ total_checks: u64 checks: TreeMap[u64, str] user_checks: TreeMap[Address, u64] total_great_deals: u64 total_fair: u64 total_overpriced: u64 total_scams: u64 total_insufficient: u64 def __init__(self): self.total_checks = 0 self.total_great_deals = 0 self.total_fair = 0 self.total_overpriced = 0 self.total_scams = 0 self.total_insufficient = 0 # ═══════════════════════════════════════ # HELPERS # ═══════════════════════════════════════ def _extract_price_value(self, price_str: str) -> float: """Extract numeric price from string like '$29.99' or '29.99 USD'""" import re try: match = re.search(r'[\d,]+\.?\d*', str(price_str).replace(',', '')) if match: return float(match.group()) except: pass return 0.0 def _normalize_ai_result( self, raw_result: dict, product_name_fallback: str, listed_price_fallback: str, page_blocked: bool = False, ) -> str: """Normalize the AI's JSON output into a deterministic record. This is where we enforce honesty: if the AI doesn't have enough data, we force INSUFFICIENT_DATA rather than letting it (or our defaults) silently produce a fake FAIR_PRICE that misleads users. """ verdict = str(raw_result.get("verdict", "")).strip().upper().replace(" ", "_") product_name = str(raw_result.get("product_name", product_name_fallback))[:200] listed_price = str(raw_result.get("listed_price", listed_price_fallback))[:50] estimated_fair = str(raw_result.get("estimated_fair_price", ""))[:50] reasoning = str(raw_result.get("reasoning", ""))[:500] try: savings = int(raw_result.get("savings_percent", 0)) except Exception: savings = 0 # Confidence: clamp to 0-100; default to 50 when missing. try: confidence = int(raw_result.get("confidence", 50)) except Exception: confidence = 50 if confidence < 0: confidence = 0 if confidence > 100: confidence = 100 # ── Honesty checks: detect when the AI couldn't actually do its job ── empty_listed = (not listed_price) or listed_price.strip().upper() in ("N/A", "NA", "NONE", "UNKNOWN", "") empty_fair = (not estimated_fair) or estimated_fair.strip().upper() in ("N/A", "NA", "NONE", "UNKNOWN", "") empty_name = (not product_name) or product_name.strip().lower() in ("unknown", "n/a", "") # Force INSUFFICIENT_DATA when the AI clearly didn't have enough info, # regardless of what verdict it tried to return. force_insufficient = ( empty_name or (empty_listed and empty_fair) or (page_blocked and empty_listed) or confidence < 25 ) if force_insufficient: verdict = VERDICT_INSUFFICIENT if not reasoning: missing = [] if empty_name: missing.append("product identity") if empty_listed: missing.append("listed price") if empty_fair: missing.append("typical market price") reasoning = ( "Could not determine " + ", ".join(missing or ["enough data"]) + (". The product page was blocked by bot detection; " "search results didn't fill the gap." if page_blocked else ".") ) + " Try the Manual Check tab with the product name and price you can see." savings = 0 estimated_fair = estimated_fair or "N/A" listed_price = listed_price or "N/A" # Scam fallback: even without AI analysis, an absurdly low price on a # famously expensive product is still a scam signal. elif (empty_fair or not reasoning) and listed_price and not empty_listed: price_val = self._extract_price_value(listed_price) known_expensive = ( "airpods", "iphone", "ipad", "macbook", "ps5", "playstation", "xbox", "samsung tv", "sony tv", "rolex", "gucci", "prada", "louis vuitton", "hermes", "rtx", "nintendo switch", ) product_lower = product_name.lower() is_expensive = any(k in product_lower for k in known_expensive) if is_expensive and price_val > 0 and price_val < 50: verdict = "SCAM_ALERT" estimated_fair = estimated_fair or "Typically $150-500+" reasoning = ( f"Listed price ${price_val:.2f} is far below typical retail for " f"{product_name}. Likely scam or counterfeit." ) savings = -90 confidence = max(confidence, 70) # Final guard: only return allowed verdicts. if verdict not in ALLOWED_VERDICTS: # Unknown verdict from the AI — treat as insufficient data, not a fake "fair". verdict = VERDICT_INSUFFICIENT if not reasoning: reasoning = "AI returned an unrecognized verdict. Try Manual Check." normalized = { "verdict": verdict, "confidence": confidence, "product_name": product_name or "Unknown", "listed_price": listed_price or "N/A", "estimated_fair_price": estimated_fair or "N/A", "savings_percent": savings, "reasoning": reasoning, "price_factors": sorted([str(f).strip().lower() for f in raw_result.get("price_factors", [])][:5]), } return json.dumps(normalized, sort_keys=True) def _record_check(self, check_id: u64, result: dict, url: str, store_name: str): verdict = result.get("verdict", "FAIR_PRICE") submitter = gl.message.sender_address record = { "id": int(check_id), "url": url, "category": result.get("_category", ""), "submitter": str(submitter), "verdict": verdict, "confidence": int(result.get("confidence", 50)), "product_name": result.get("product_name", "Unknown"), "listed_price": result.get("listed_price", "N/A"), "estimated_fair_price": result.get("estimated_fair_price", "N/A"), "savings_percent": result.get("savings_percent", 0), "reasoning": result.get("reasoning", ""), "price_factors": result.get("price_factors", []), "store_name": store_name, } self.checks[check_id] = json.dumps(record) self.total_checks += 1 current_user_checks = int(self.user_checks.get(submitter, 0)) self.user_checks[submitter] = current_user_checks + 1 if verdict == "GREAT_DEAL": self.total_great_deals += 1 elif verdict == "FAIR_PRICE": self.total_fair += 1 elif verdict == "OVERPRICED": self.total_overpriced += 1 elif verdict == "SCAM_ALERT": self.total_scams += 1 elif verdict == VERDICT_INSUFFICIENT: self.total_insufficient += 1 # ═══════════════════════════════════════ # CHECK PRICE BY URL # ═══════════════════════════════════════ @gl.public.write def check_price(self, product_url: str, category: str) -> dict: if not product_url: raise UserError("Product URL cannot be empty") if not product_url.startswith(("http://", "https://")): raise UserError("Product URL must start with http:// or https://") VALID_CATEGORIES = ["electronics", "clothing", "home", "beauty", "sports", "food", "other"] if category not in VALID_CATEGORIES: raise UserError(f"Invalid category. Choose from: {', '.join(VALID_CATEGORIES)}") check_id = self.total_checks # Build the search query OUTSIDE the nondet block so every validator # uses the exact same query string (deterministic input). search_query = _smart_search_query(product_url) or category def nondet_block(): # 1. Try to scrape the actual product page. Big retailers (Amazon, # Walmart, Best Buy) often block bots — we detect that below. try: page_raw = str(gl.nondet.web.render(product_url))[:WEB_TRUNCATE] except Exception: page_raw = "" page_blocked = _looks_like_bot_wall(page_raw) page_data = "" if page_blocked else page_raw # 2. Search the product name to identify what it is + see typical prices. # We use DuckDuckGo's HTML endpoint — it is explicitly scraper-friendly # (no captcha / rate limits for headless renders), unlike Google which # almost always serves a bot wall to gl.nondet.web.render. q = search_query.replace(' ', '+') try: product_search = str(gl.nondet.web.render( f"https://html.duckduckgo.com/html/?q={q}" ))[:WEB_TRUNCATE // 2] except Exception: product_search = "" # 3. Targeted price search — much higher signal for "what's the typical price". try: price_search = str(gl.nondet.web.render( f"https://html.duckduckgo.com/html/?q={q}+price+retail+typical+cost+usd" ))[:WEB_TRUNCATE // 3] except Exception: price_search = "" page_status = "BLOCKED by bot detection" if page_blocked else ( f"available ({len(page_data)} chars)" if page_data else "empty" ) task = f"""You are PriceGuard, an expert AI price analyst on the GenLayer protocol. TASK: Identify the product, determine the listed price, compare to typical market price, and return a JSON verdict. You MUST return INSUFFICIENT_DATA if you cannot reliably identify the product OR cannot determine BOTH the listed and the typical price. CATEGORY: {category} URL: {product_url} LIKELY PRODUCT KEYWORDS (extracted from URL): {search_query} PAGE STATUS: {page_status} === PRODUCT PAGE CONTENT === {page_data if page_data else '(no usable content - the site blocked the bot or returned an empty page)'} === END PRODUCT PAGE === === GOOGLE SEARCH (product) === {product_search if product_search else '(no search results returned)'} === END SEARCH === === GOOGLE SEARCH (typical price) === {price_search if price_search else '(no price search results returned)'} === END SEARCH === DECISION RULES: 1. PRODUCT IDENTIFICATION - Use the PAGE CONTENT first; if blocked, use the URL keywords + search results. - If you still cannot identify the product with reasonable confidence, set verdict = "INSUFFICIENT_DATA" and explain what's missing. 2. LISTED PRICE - Read it from PAGE CONTENT. - If the page is blocked, look in product search results (some retailers' prices appear in Google snippets). - If you cannot find a listed price anywhere, set verdict = "INSUFFICIENT_DATA". Do NOT guess. 3. TYPICAL MARKET PRICE - Use the price search results (they often include real retailer prices). - If search results don't reveal typical prices, you may use widely-known MSRP for famous products (iPhone, PlayStation, MacBook, etc.) — be explicit in reasoning. - If neither works, set verdict = "INSUFFICIENT_DATA". 4. VERDICT (only when you have BOTH listed AND typical price): - "SCAM_ALERT": listed is <50% of typical AND no legitimate explanation (e.g., not labeled "used"/"refurbished"/"clearance") - "GREAT_DEAL": listed is 20-50% below typical, listing seems legitimate - "FAIR_PRICE": listed within ±15% of typical - "OVERPRICED": listed is 20%+ above typical 5. CONFIDENCE - Score 0-100 reflecting how sure you are about your verdict. - Below 40 means you should probably have returned INSUFFICIENT_DATA. Return ONLY this JSON object (no markdown, no commentary, no code fences): {{"verdict": "GREAT_DEAL|FAIR_PRICE|OVERPRICED|SCAM_ALERT|INSUFFICIENT_DATA", "confidence": , "product_name": "", "listed_price": "", "estimated_fair_price": "", "savings_percent": , "reasoning": "<2-3 sentences explaining your verdict>", "price_factors": ["", ...]}}""" result = gl.nondet.exec_prompt(task) try: parsed = json.loads(result) except Exception: parsed = {} return self._normalize_ai_result(parsed, "Unknown", "N/A", page_blocked) # Comparative principle — slightly relaxed so consensus survives the # natural variance between LLMs and search results across validators. # Critical fields (verdict, product identity) must match; numeric # fields have wider tolerance because search-derived prices vary. comparative_principle = ( "The outputs must agree on the 'verdict' field. " "The 'product_name' fields must describe the same product (case, whitespace, " "and minor wording differences are acceptable; e.g. 'Apple AirPods Pro' and " "'AirPods Pro 2nd Gen' are the same product). " "Numeric fields 'listed_price' and 'estimated_fair_price' must be within ±10% of each other. " "'savings_percent' must be within ±15 points. " "'reasoning' may be reworded freely. " "If both outputs return verdict=INSUFFICIENT_DATA, that itself is consensus." ) result_str = gl.eq_principle.prompt_comparative(nondet_block, comparative_principle) result = json.loads(result_str) result["_category"] = category self._record_check(check_id, result, product_url, "") return result # ═══════════════════════════════════════ # MANUAL PRICE CHECK # ═══════════════════════════════════════ @gl.public.write def check_price_manual(self, product_name: str, listed_price: str, store_name: str, category: str) -> dict: if not product_name or not listed_price: raise UserError("Product name and price are required") VALID_CATEGORIES = ["electronics", "clothing", "home", "beauty", "sports", "food", "other"] if category not in VALID_CATEGORIES: raise UserError(f"Invalid category. Choose from: {', '.join(VALID_CATEGORIES)}") check_id = self.total_checks def nondet_block(): # Two complementary searches: (1) general product info, (2) targeted # price query. We use DuckDuckGo's HTML endpoint because Google almost # always returns a bot-wall / captcha page to headless renders, which # was making nearly every manual check resolve to INSUFFICIENT_DATA. base_q = product_name.replace(" ", "+") try: product_search = str(gl.nondet.web.render( f"https://html.duckduckgo.com/html/?q={base_q}" ))[:WEB_TRUNCATE // 2] except Exception: product_search = "" try: price_search = str(gl.nondet.web.render( f"https://html.duckduckgo.com/html/?q={base_q}+price+retail+typical+cost+usd" ))[:WEB_TRUNCATE // 2] except Exception: price_search = "" task = f"""You are PriceGuard, an expert AI price analyst on the GenLayer protocol. TASK: Determine whether the listed price is fair for the given product. Return INSUFFICIENT_DATA if you cannot determine a typical market price from the search results AND don't know the product well enough from common knowledge. PRODUCT: {product_name} LISTED PRICE: {listed_price} STORE: {store_name or '(not provided)'} CATEGORY: {category} === GOOGLE SEARCH (product info) === {product_search if product_search else '(no search results returned)'} === END SEARCH === === GOOGLE SEARCH (typical price) === {price_search if price_search else '(no price search results returned)'} === END SEARCH === DECISION RULES: 1. Find typical retail prices in the search results above. If neither search returned useful prices and the product isn't a famous one with widely-known MSRP, return verdict = "INSUFFICIENT_DATA". 2. If the listed price is dramatically below typical (>50% off) and the listing has no legitimate explanation, treat as "SCAM_ALERT". 3. Verdict thresholds: - "SCAM_ALERT": listed is <50% of typical with no legitimate explanation - "GREAT_DEAL": 20-50% below typical - "FAIR_PRICE": within ±15% of typical - "OVERPRICED": 20%+ above typical - "INSUFFICIENT_DATA": you can't determine typical price with confidence 4. Provide a confidence score (0-100). Below 25 means you should return INSUFFICIENT_DATA. Return ONLY this JSON object (no markdown, no commentary, no code fences): {{"verdict":"GREAT_DEAL|FAIR_PRICE|OVERPRICED|SCAM_ALERT|INSUFFICIENT_DATA","confidence":,"product_name":"{product_name}","listed_price":"{listed_price}","estimated_fair_price":"$XXX or N/A","savings_percent":0,"reasoning":"<2-3 sentences>","price_factors":["factor1","factor2"]}}""" result = gl.nondet.exec_prompt(task) try: parsed = json.loads(result) except Exception: parsed = {} return self._normalize_ai_result(parsed, product_name, listed_price, page_blocked=False) comparative_principle = ( "The outputs must agree on the 'verdict' field. " "The 'product_name' fields must describe the same product (case and minor " "wording differences are acceptable). " "Numeric fields 'listed_price' and 'estimated_fair_price' must be within ±10% of each other. " "'savings_percent' must be within ±15 points. " "'reasoning' may be reworded freely. " "If both outputs return verdict=INSUFFICIENT_DATA, that itself is consensus." ) result_str = gl.eq_principle.prompt_comparative(nondet_block, comparative_principle) result = json.loads(result_str) result["_category"] = category self._record_check(check_id, result, "", store_name) return result # ═══════════════════════════════════════ # READ METHODS # ═══════════════════════════════════════ @gl.public.view def get_check(self, check_id: int) -> dict: try: return json.loads(self.checks[check_id]) except: return {} @gl.public.view def get_recent_checks(self, count: int) -> list: results = [] start = max(0, self.total_checks - count) for i in range(start, self.total_checks): try: results.append(json.loads(self.checks[i])) except: pass return results @gl.public.view def get_stats(self) -> dict: total = max(1, self.total_checks) return { "total_checks": int(self.total_checks), "total_great_deals": int(self.total_great_deals), "total_fair": int(self.total_fair), "total_overpriced": int(self.total_overpriced), "total_scams": int(self.total_scams), "total_insufficient": int(self.total_insufficient), "scam_rate": round((int(self.total_scams) / total) * 100, 1), } @gl.public.view def get_user_stats(self, user: Address) -> dict: try: checks = int(self.user_checks[user]) except: checks = 0 return {"checks": checks}