ci: add code example linting with genvm-linter (#364)

- Add lint-code-examples.py script that extracts Python blocks from MDX
  files and validates them: runner hash pinning, deprecated API detection,
  AST lint via genvm-lint, and syntax checks for snippets
- Add CI workflow (lint-code-examples.yml) triggered on PRs and pushes
  to main when pages/ or the lint script change
- Fix deprecated APIs across 20 MDX files: gl.get_webpage -> gl.nondet.web.get,
  gl.eq_principle_strict_eq -> gl.eq_principle.strict_eq,
  gl.eq_principle_prompt_comparative -> gl.eq_principle.prompt_comparative,
  gl.eq_principle_prompt_non_comparative -> gl.eq_principle.prompt_non_comparative,
  gl.exec_prompt -> gl.nondet.exec_prompt
- Pin all runner hashes from "test" to specific version

Author: MuncleUscles

.github/workflows/lint-code-examples.yml

@@ -0,0 +1,23 @@
+name: Lint Code Examples
+
+on:
+  pull_request:
+    paths:
+      - 'pages/**/*.mdx'
+      - 'scripts/lint-code-examples.py'
+  push:
+    branches: [main]
+    paths:
+      - 'pages/**/*.mdx'
+      - 'scripts/lint-code-examples.py'
+
+jobs:
+  lint-code-examples:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: pip install genvm-linter
+      - run: python scripts/lint-code-examples.py

pages/api-references/genlayer-test.mdx

@@ -139,7 +139,7 @@ assert default_account != other_account
 For the following code examples, we'll use a Storage Intelligent Contract as a reference:
 
 ```python
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 
 from genlayer import *
 

pages/developers/intelligent-contracts/crafting-prompts.mdx

@@ -15,7 +15,7 @@ When crafting prompts for LLMs, it's important to use a format that clearly and
 In the example **Wizard of Coin** contract below, we want the LLM to decide whether the wizard should give the coin to an adventurer.
 
 ```python
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 from genlayer import *
 
 import json
@@ -55,13 +55,14 @@ This result should be perfectly parseable by a JSON parser without errors.
 """
 
         def nondet():
-            res = gl.exec_prompt(prompt)
-            res = res.replace("```json", "").replace("```", "")
+            res = gl.nondet.exec_prompt(prompt)
+            backticks = "``" + "`"
+            res = res.replace(backticks + "json", "").replace(backticks, "")
             print(res)
             dat = json.loads(res)
             return dat["give_coin"]
 
-        result = gl.eq_principle_strict_eq(nondet)
+        result = gl.eq_principle.strict_eq(nondet)
         assert isinstance(result, bool)
         self.have_coin = result
 

pages/developers/intelligent-contracts/examples/fetch-github-profile.mdx

@@ -3,7 +3,7 @@
 The FetchGitHubProfile contract demonstrates how to fetch and store GitHub profile content within an intelligent contract. This contract shows how to use the [comparative equivalence principle](/developers/intelligent-contracts/equivalence-principle#comparative-equivalence-principle) to ensure all nodes agree on the same profile content.
 
 ```python
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 
 from genlayer import *
 import typing
@@ -20,9 +20,10 @@ class FetchGitHubProfile(gl.Contract):
         github_profile_url = "https://github.com/"+github_handle
 
         def fetch_github_profile_page_content() -> str:
-            return gl.get_webpage(github_profile_url, mode="text")
-    
-        self.github_profile = gl.eq_principle_strict_eq(fetch_github_profile_page_content)
+            response = gl.nondet.web.get(github_profile_url)
+            return response.body.decode("utf-8")
+
+        self.github_profile = gl.eq_principle.strict_eq(fetch_github_profile_page_content)
 
     @gl.public.view
     def show_github_profile(self) -> str:       
@@ -35,14 +36,14 @@ class FetchGitHubProfile(gl.Contract):
 - **Write Method**: 
   - `fetch_github_profile(github_handle)` takes a GitHub username and retrieves their profile content.
   - Constructs the profile URL using the provided handle.
-  - Uses `gl.eq_principle_strict_eq()` to ensure all nodes agree on the same profile content.
+  - Uses `gl.eq_principle.strict_eq()` to ensure all nodes agree on the same profile content.
 - **Read Method**: 
   - `show_github_profile()` returns the stored profile content.
 
 ## Key Components
 
-1. **GitHub Integration**: The contract uses `gl.get_webpage()` to fetch content from GitHub profiles.
-2. **Deterministic Execution**: `gl.eq_principle_strict_eq()` ensures that all nodes in the network arrive at the same exact content.
+1. **GitHub Integration**: The contract uses `gl.nondet.web.get()` to fetch content from GitHub profiles.
+2. **Deterministic Execution**: `gl.eq_principle.strict_eq()` ensures that all nodes in the network arrive at the same exact content.
 3. **State Management**: The contract maintains a single string state variable that stores the profile content.
 
 ## Deploying the Contract

pages/developers/intelligent-contracts/examples/fetch-web-content.mdx

@@ -3,7 +3,7 @@
 The FetchWebContent contract demonstrates how to fetch and store web content within an intelligent contract. This contract shows how to use the [comparative equivalence principle](/developers/intelligent-contracts/equivalence-principle#comparative-equivalence-principle) to ensure all nodes agree on the same web content.
 
 ```python
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 
 from genlayer import *
 import typing
@@ -19,9 +19,10 @@ class FetchWebContent(gl.Contract):
     def fetch_web_content(self) -> typing.Any:
 
         def fetch_web_url_content() -> str:
-            return gl.get_webpage("https://example.com/", mode="text")
-    
-        self.content = gl.eq_principle_strict_eq(fetch_web_url_content)
+            response = gl.nondet.web.get("https://example.com/")
+            return response.body.decode("utf-8")
+
+        self.content = gl.eq_principle.strict_eq(fetch_web_url_content)
 
     @gl.public.view
     def show_content(self) -> str:       
@@ -33,15 +34,15 @@ class FetchWebContent(gl.Contract):
 - **Initialization**: The `FetchWebContent` class initializes with an empty string in the `content` variable.
 - **Write Method**: 
   - `fetch_web_content()` retrieves content from a web page and stores it.
-  - It contains an inner function `fetch_web_url_content()` that uses `gl.get_webpage()` to fetch content.
-  - Uses `gl.eq_principle_strict_eq()` to ensure all nodes agree on the same content.
+  - It contains an inner function `fetch_web_url_content()` that uses `gl.nondet.web.get()` to fetch content.
+  - Uses `gl.eq_principle.strict_eq()` to ensure all nodes agree on the same content.
 - **Read Method**: 
   - `show_content()` returns the stored web content.
 
 ## Key Components
 
-1. **Web Integration**: The contract uses `gl.get_webpage()` to fetch content from web URLs.
-2. **Deterministic Execution**: `gl.eq_principle_strict_eq()` ensures that all nodes in the network arrive at the same exact content.
+1. **Web Integration**: The contract uses `gl.nondet.web.get()` to fetch content from web URLs.
+2. **Deterministic Execution**: `gl.eq_principle.strict_eq()` ensures that all nodes in the network arrive at the same exact content.
 3. **State Management**: The contract maintains a single string state variable that stores the web content.
 
 ## Deploying the Contract
@@ -101,7 +102,7 @@ You can monitor the contract's behavior through transaction logs, which will sho
 
 ## HTML Mode for Web Content
 
-The `gl.get_webpage()` function supports different modes for retrieving web content. While `mode="text"` returns the plain text content, `mode="html"` allows you to retrieve the complete HTML `<body>` of the webpage.
+The `gl.nondet.web.get()` function supports different modes for retrieving web content. While the default mode returns the plain text content, `gl.nondet.web.render()` with `mode="html"` allows you to retrieve the complete HTML `<body>` of the webpage.
 
 Here's an example of using HTML mode:
 
@@ -115,9 +116,9 @@ class FetchHTMLContent(gl.Contract):
     @gl.public.write
     def fetch_html_content(self) -> typing.Any:
         def fetch_web_url_html() -> str:
-            return gl.get_webpage("https://example.com/", mode="html")
-    
-        self.html_content = gl.eq_principle_strict_eq(fetch_web_url_html)
+            return gl.nondet.web.render("https://example.com/", mode='html')
+
+        self.html_content = gl.eq_principle.strict_eq(fetch_web_url_html)
 
     @gl.public.view
     def show_html_content(self) -> str:       

pages/developers/intelligent-contracts/examples/github-profile-projects.mdx

@@ -3,7 +3,7 @@
 The GitHubProfilesRepositories contract demonstrates how to fetch GitHub profile data, analyze repository counts, and store profiles of high-contributing developers. This contract shows how to use the [comparative equivalence principle](/developers/intelligent-contracts/equivalence-principle#comparative-equivalence-principle) along with pattern matching to process web content.
 
 ```python
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 
 from genlayer import *
 import typing
@@ -20,7 +20,8 @@ class GitHubProfilesRepositories(gl.Contract):
         github_profile_url = "https://github.com/"+github_handle
 
         def fetch_github_profile_repositories() -> int:
-            profile_web_page = gl.get_webpage(github_profile_url, mode="text")
+            response = gl.nondet.web.get(github_profile_url)
+            profile_web_page = response.body.decode("utf-8")
             # Regular expression to find the number between "Repositories" and "Projects"
             pattern = r"Repositories\s+(\d+)\s+Projects"
 
@@ -33,7 +34,7 @@ class GitHubProfilesRepositories(gl.Contract):
             else:
                 return 0
 
-        repositories = gl.eq_principle_strict_eq(fetch_github_profile_repositories)
+        repositories = gl.eq_principle.strict_eq(fetch_github_profile_repositories)
 
         if repositories > 25:
             self.github_profiles.append(github_handle)
@@ -55,9 +56,9 @@ class GitHubProfilesRepositories(gl.Contract):
 
 ## Key Components
 
-1. **GitHub Integration**: Uses `gl.get_webpage()` to fetch profile content.
+1. **GitHub Integration**: Uses `gl.nondet.web.get()` to fetch profile content.
 2. **Pattern Matching**: Employs regular expressions to extract repository counts.
-3. **Deterministic Execution**: Uses `gl.eq_principle_strict_eq()` to ensure network consensus.
+3. **Deterministic Execution**: Uses `gl.eq_principle.strict_eq()` to ensure network consensus.
 4. **Conditional Storage**: Only stores profiles meeting specific criteria.
 
 ## Deploying the Contract

pages/developers/intelligent-contracts/examples/github-profile-summary.mdx

@@ -3,7 +3,7 @@
 The GitHubProfilesSummaries contract demonstrates how to fetch GitHub profile data and generate AI-powered summaries of user profiles. This contract shows how to combine web scraping with AI analysis using both [comparative](/developers/intelligent-contracts/equivalence-principle#comparative-equivalence-principle) and [non-comparative](/developers/intelligent-contracts/equivalence-principle#non-comparative-equivalence-principle) equivalence principles.
 
 ```python
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 
 from genlayer import *
 import typing
@@ -25,17 +25,18 @@ class GitHubProfilesSummaries(gl.Contract):
         github_profile_url = "https://github.com/"+github_handle
 
         def fetch_github_profile_summaries() -> str:
-            return gl.get_webpage(github_profile_url, mode="text")
+            response = gl.nondet.web.get(github_profile_url)
+            return response.body.decode("utf-8")
 
-        profile_content = gl.eq_principle_strict_eq(fetch_github_profile_summaries)
+        profile_content = gl.eq_principle.strict_eq(fetch_github_profile_summaries)
 
         task = """Given the web page content of a github profile in HTML format, generate a comprehensive
 summary of the profile mentioning the key meta attributes and the GitHub contribution most important metrics"""
 
         criteria = """The summary provided should include different metrics and a summary of a GitHub profile"""
 
         profile_summary = (
-            gl.eq_principle_prompt_non_comparative(
+            gl.eq_principle.prompt_non_comparative(
                 lambda: profile_content,
                 task=task,
                 criteria=criteria,
@@ -61,7 +62,7 @@ summary of the profile mentioning the key meta attributes and the GitHub contrib
 ## Key Components
 
 1. **Data Storage**: Uses `TreeMap` for efficient key-value storage of profile summaries.
-2. **Web Fetching**: Uses `gl.get_webpage()` with strict equivalence for deterministic content retrieval.
+2. **Web Fetching**: Uses `gl.nondet.web.get()` with strict equivalence for deterministic content retrieval.
 3. **AI Analysis**: Uses non-comparative equivalence for generating profile summaries.
 4. **Duplicate Prevention**: Includes checks to prevent regenerating existing summaries.
 

pages/developers/intelligent-contracts/examples/llm-hello-world-non-comparative.mdx

@@ -3,7 +3,7 @@
 The LlmHelloWorldNonComparative contract demonstrates a simple example of integrating AI capabilities within an intelligent contract without requiring that all the validators execute the full task. They just need to evaluate the leader's response against the specified criteria. This is done by using the [non-comparative equivalence principle](/developers/intelligent-contracts/equivalence-principle#non-comparative-equivalence-principle).
 
 ```python
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 
 from genlayer import *
 import typing
@@ -17,7 +17,7 @@ class LlmHelloWorldNonComparative(gl.Contract):
 
     @gl.public.write
     def set_message(self) -> typing.Any:
-        self.message = gl.eq_principle_prompt_non_comparative(
+        self.message = gl.eq_principle.prompt_non_comparative(
             lambda: "There is no context, I just want you to answer with truthy value in python (for example: 'yes', 'True', 1)",
             task="Answer with truthy value in python (for example: 'yes', 'True', 1)",
             criteria="Answer should be a truthy value in python"
@@ -33,7 +33,7 @@ class LlmHelloWorldNonComparative(gl.Contract):
 - **Initialization**: The `LlmHelloWorldNonComparative` class initializes with an empty string in the `message` variable.
 - **Write Method**: 
   - `set_message()` uses AI functionality to generate and store a message.
-  - Uses `gl.eq_principle_prompt_non_comparative()` with three parameters:
+  - Uses `gl.eq_principle.prompt_non_comparative()` with three parameters:
     - A lambda function providing the prompt
     - A task description
     - Validation criteria for the response
@@ -43,7 +43,7 @@ class LlmHelloWorldNonComparative(gl.Contract):
 ## Key Components
 
 1. **AI Integration**: The contract uses non-comparative equivalence principle to interact with an AI model.
-2. **Deterministic Execution**: `gl.eq_principle_prompt_non_comparative()` ensures that all nodes in the network accept responses that meet the specified criteria.
+2. **Deterministic Execution**: `gl.eq_principle.prompt_non_comparative()` ensures that all nodes in the network accept responses that meet the specified criteria.
 3. **State Management**: The contract maintains a single string state variable that stores the AI response.
 
 ## Deploying the Contract

pages/developers/intelligent-contracts/examples/llm-hello-world.mdx

@@ -3,7 +3,7 @@
 The LlmHelloWorld contract demonstrates a simple example of integrating AI capabilities within an intelligent contract. This contract shows how to use the [comparative equivalence principle](/developers/intelligent-contracts/equivalence-principle#comparative-equivalence-principle) to call an LLM and store the response in the contract state.
 
 ```python
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 
 from genlayer import *
 import typing
@@ -20,11 +20,11 @@ class LlmHelloWorld(gl.Contract):
 
         def get_message() -> str:
             task = "There is no context, I just want you to answer with a string equal to 'yes'"
-            result = gl.exec_prompt(task)
+            result = gl.nondet.exec_prompt(task)
             print(result)
             return result
 
-        self.message = gl.eq_principle_strict_eq(get_message)
+        self.message = gl.eq_principle.strict_eq(get_message)
 
     @gl.public.view
     def get_message(self) -> str:       
@@ -37,14 +37,14 @@ class LlmHelloWorld(gl.Contract):
 - **Write Method**: 
   - `set_message()` uses AI functionality to generate and store a message.
   - It contains an inner function `get_message()` that prompts an AI model with a simple task.
-  - Uses `gl.eq_principle_strict_eq()` to ensure deterministic AI responses across the network.
+  - Uses `gl.eq_principle.strict_eq()` to ensure deterministic AI responses across the network.
 - **Read Method**: 
   - `get_message()` returns the stored message.
 
 ## Key Components
 
-1. **AI Integration**: The contract uses `gl.exec_prompt()` to interact with an AI model.
-2. **Deterministic Execution**: `gl.eq_principle_strict_eq()` ensures that all nodes in the network arrive at the same exact result.
+1. **AI Integration**: The contract uses `gl.nondet.exec_prompt()` to interact with an AI model.
+2. **Deterministic Execution**: `gl.eq_principle.strict_eq()` ensures that all nodes in the network arrive at the same exact result.
 3. **State Management**: The contract maintains a single string state variable that stores the AI response.
 
 ## Deploying the Contract

pages/developers/intelligent-contracts/examples/prediction.mdx

@@ -3,7 +3,7 @@
 The Prediction Market contract sets up a scenario to determine the outcome of a football game between two teams. The contract uses the Equivalence Principle to ensure accurate and consistent decision-making based on the game's resolution data.
 
 ```python filename="PredictionMarket" copy
-# { "Depends": "py-genlayer:test" }
+# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }
 
 from genlayer import *
 
@@ -49,7 +49,8 @@ class PredictionMarket(gl.Contract):
             return "Already resolved"
 
         def nondet() -> str:
-            web_data = gl.get_webpage(self.resolution_url, mode="text")
+            response = gl.nondet.web.get(self.resolution_url)
+            web_data = response.body.decode("utf-8")
             print(web_data)
 
             task = f"""In the following web page, find the winning team in a matchup between the following teams:
@@ -73,11 +74,11 @@ class PredictionMarket(gl.Contract):
             your output must be only JSON without any formatting prefix or suffix.
             This result should be perfectly parsable by a JSON parser without errors.
             """
-            result = gl.exec_prompt(task).replace("```json", "").replace("```", "")
+            result = gl.nondet.exec_prompt(task).replace("```json", "").replace("```", "")
             print(result)
             return json.dumps(json.loads(result), sort_keys=True)
 
-        result_json = json.loads(gl.eq_principle_strict_eq(nondet))
+        result_json = json.loads(gl.eq_principle.strict_eq(nondet))
 
         if result_json["winner"] > -1:
             self.has_resolved = True