init

Author: Dhubbs

.github/workflows/build-and-release.yml

@@ -0,0 +1,69 @@
+name: Build and Release
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  build-and-release:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v2
+
+    - name: Build Docker image
+      uses: docker/build-push-action@v4
+      with:
+        context: .
+        load: true
+        tags: |
+          my-proof:${{ github.run_number }}
+          my-proof:latest
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+
+    - name: Export image to file
+      run: |
+        docker save my-proof:latest | gzip > my-proof-${{ github.run_number }}.tar.gz
+    - name: Generate release body
+      run: |
+        echo "Image SHA256: $(sha256sum my-proof-${{ github.run_number }}.tar.gz | cut -d' ' -f1)" >> release_body.txt
+    - name: Upload image
+      uses: actions/upload-artifact@v3
+      with:
+        name: my-proof-image
+        path: my-proof-${{ github.run_number }}.tar.gz
+
+    - name: Create Release and Upload Assets
+      uses: softprops/action-gh-release@v1
+      if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: v${{ github.run_number }}
+        name: Release v${{ github.run_number }}
+        body_path: release_body.txt
+        draft: false
+        prerelease: false
+        files: |
+          ./my-proof-${{ github.run_number }}.tar.gz
+    - name: Log build result
+      if: always()
+      run: |
+        if [ ${{ job.status }} == "success" ]; then
+          echo "Build and release completed successfully"
+        else
+          echo "Build and release failed"
+        fi

.gitignore

@@ -0,0 +1,3 @@
+
+.DS_Store
+/venv

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.12-slim
+
+
+WORKDIR /app
+
+COPY . /app
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+CMD ["python", "-m", "my_proof"]

LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright © 2024 Corsali, Inc. dba Vana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,96 @@
+# VanaTensor Satya Proof of Contribution
+
+This repository creating a [proof of contribution](https://docs.vana.org/vana/core-concepts/key-elements/proof-of-contribution) tasks using Python. It is executed on Vana's Satya Network, a group of highly confidential and secure compute nodes that can validate data without revealing its contents to the node operator.
+
+## Overview
+
+This poc provides a basic structure for building proof tasks that:
+
+1. Read input files from the `/input` directory.
+2. Process the data securely, running any necessary validations to prove the data authentic, unique, high quality, etc.
+3. Write proof results to the `/output/results.json` file in the following format:
+
+```json
+{
+  "dlp_id": 1,
+  "valid": true,
+  "score": 0.7614457831325301,
+  "time_minimums": 1.0,
+  "time_correlation": 1.0,
+  "time_distribution": 1.0,
+  "repeat_anwsers": 1.0,
+  "both_sides": 0,
+  "model_distribution": 0.0,
+  "poison_data": 0.0,
+  "uniqueness": 0.0
+}
+```
+
+The project is designed to work with Intel TDX (Trust Domain Extensions), providing hardware-level isolation and security guarantees for confidential computing workloads.
+
+## Project Structure
+
+- `my_proof/`: Contains the main proof logic
+  - `proof.py`: Implements the proof generation logic
+  - `__main__.py`: Entry point for the proof execution
+  - `models/`: Data models for the proof system
+- `demo/`: Contains sample input and output for testing
+- `Dockerfile`: Defines the container image for the proof task
+- `requirements.txt`: Python package dependencies
+
+## Customizing the Proof Logic
+
+The main proof logic is implemented in `my_proof/proof.py`. To customize it, update the `Proof.generate()` function to change how input files are processed.
+
+The proof can be configured using environment variables:
+
+- `USER_EMAIL`: The email address of the data contributor, to verify data ownership
+
+## Local Development
+
+To setup venv and install dependencies:
+
+```bash
+python3 -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+export PYTHONPATH=.
+```
+
+To run the proof locally for testing, you can use Docker:
+
+```bash
+docker build -t my-proof .
+```
+
+```bash
+docker run --rm --volume $(pwd)/input:/input --volume $(pwd)/output:/output -e AWS_ACCESS_KEY_ID=<your-access-key-id> -e AWS_SECRET_ACCESS_KEY=<your-secret-access-key> my-proof
+```
+
+## Running with Intel TDX
+
+Intel TDX (Trust Domain Extensions) provides hardware-based memory encryption and integrity protection for virtual machines. To run this container in a TDX-enabled environment, follow your infrastructure provider's specific instructions for deploying confidential containers.
+
+Common volume mounts and environment variables:
+
+```bash
+docker run --rm --volume /path/to/input:/input --volume /path/to/output:/output -e AWS_ACCESS_KEY_ID=<your-access-key-id> -e AWS_SECRET_ACCESS_KEY=<your-secret-access-key> my-proof
+```
+
+Remember to populate the `/input` directory with the files you want to process.
+
+## Security Features
+
+This proof leverages several security features:
+
+1. **Hardware-based Isolation**: The proof runs inside a TDX-protected environment, isolating it from the rest of the system
+2. **Input/Output Isolation**: Input and output directories are mounted separately, ensuring clear data flow boundaries
+3. **Minimal Container**: Uses a minimal Python base image to reduce attack surface
+
+## Contributing
+
+If you have suggestions for improving this poc, please open an issue or submit a pull request.
+
+## License
+
+[MIT License](LICENSE)

my_proof/Swipes.json

@@ -0,0 +1,27 @@
+[
+  {
+    "imgUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcS-iIwAvtGqGJj7uq6Ub17LIDPR3j82UiLOdA&s",
+    "imgText": "Horse",
+    "userResponse": 1
+  },
+  {
+    "imgUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTLcD2uF7NRv4r285_j3RADo9gjFCXsVaJ74g&s",
+    "imgText": "Car",
+    "userResponse": 1
+  },
+  {
+    "imgUrl": "https://i.natgeofe.com/n/4cebbf38-5df4-4ed0-864a-4ebeb64d33a4/NationalGeographic_1468962_16x9.jpg",
+    "imgText": "Cat",
+    "userResponse": 1
+  },
+  {
+    "imgUrl": "https://i.natgeofe.com/n/4cebbf38-5df4-4ed0-864a-4ebeb64d33a4/NationalGeographic_1468962_16x9.jpg",
+    "imgText": "Dog",
+    "userResponse": 1
+  },
+  {
+    "imgUrl": "https://i.natgeofe.com/n/4cebbf38-5df4-4ed0-864a-4ebeb64d33a4/NationalGeographic_1468962_16x9.jpg",
+    "imgText": "Cat",
+    "userResponse": 0
+  }
+]

my_proof/__init__.py

@@ -0,0 +1,48 @@
+import json
+import logging
+import os
+import sys
+import traceback
+import zipfile
+from typing import Dict, Any
+
+from my_proof.proof import Proof
+
+INPUT_DIR, OUTPUT_DIR = '/input', '/output'
+
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+
+
+def load_config() -> Dict[str, Any]:
+    """Load proof configuration from environment variables."""
+    config = {
+        'dlp_id': 1,#to be changed
+        'input_dir': INPUT_DIR,
+    }
+    logging.info(f"Using config: {json.dumps(config, indent=2)}")
+    return config
+
+
+def run() -> None:
+    """Generate proofs for all input files."""
+    config = load_config()
+    input_files_exist = os.path.isdir(INPUT_DIR) and bool(os.listdir(INPUT_DIR))
+
+    if not input_files_exist:
+        raise FileNotFoundError(f"No input files found in {INPUT_DIR}")
+
+    proof = Proof(config)
+    proof_response = proof.generate()
+
+    output_path = os.path.join(OUTPUT_DIR, "results.json")
+    with open(output_path, 'w') as f:
+        json.dump(proof_response.dict(), f, indent=2)
+    logging.info(f"Proof generation complete: {proof_response}")
+
+if __name__ == "__main__":
+    try:
+        run()
+    except Exception as e:
+        logging.error(f"Error during proof generation: {e}")
+        traceback.print_exc()
+        sys.exit(1)

my_proof/__main__.py

@@ -0,0 +1,68 @@
+import json
+from typing import List, Dict, Any
+from openai import OpenAI
+
+class SwipeValidation:
+    def __init__(self):
+        self.client = OpenAI(api_key="")#needs to be in env
+        
+    def _verify_image_content(self, image_url: str, expected_object: str) -> bool:
+        try:
+            # Create the prompt for GPT-4 Vision
+            prompt = f"Is there a {expected_object.lower()} in this image? Please answer with just 'yes' or 'no'."
+            
+            response = self.client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {"type": "image_url", "image_url": {"url": image_url}}
+                        ]
+                    }
+                ],
+                max_tokens=10
+            )
+            
+            # Get the response and normalize it
+            ai_response = response.choices[0].message.content.lower().strip()
+            return 'yes' in ai_response
+            
+        except Exception as e:
+            print(f"Error processing image {image_url}: {str(e)}")
+            return False
+    
+    def validate(self, data: List[Dict[str, Any]]) -> float:
+        if not data:
+            return 0.0
+        
+        correct_validations = 0
+        total_validations = len(data)
+        
+        for item in data:
+            # Get the image URL and expected object from the data
+            image_url = item['imgUrl']
+            expected_object = item['imgText']
+            user_response = bool(item['userResponse'])
+            
+            # Verify with GPT-4 Vision
+            ai_sees_object = self._verify_image_content(image_url, expected_object)
+            
+            # Compare AI's response with user's response
+            if ai_sees_object == user_response:
+                correct_validations += 1
+        
+        # Calculate and return the accuracy score (0.0 to 1.0)
+        return correct_validations / total_validations
+
+
+if __name__ == "__main__":
+
+    with open("Swipes.json", "r") as f:
+        data = json.load(f)
+
+    validator = SwipeValidation()
+    results = validator.validate(data)
+    print(f"Validation accuracy: {results:.2%}")
+    

my_proof/checks.py

@@ -0,0 +1,14 @@
+from typing import Dict, Optional, Any
+
+from pydantic import BaseModel
+
+
+class ProofResponse(BaseModel):
+    dlp_id: int
+    valid: bool = False
+    score: float = 0.0
+    uniqueness: float = 0.0
+    quality: float = 0.0
+    ownership: float = 1.0
+    authenticity: float = 1.0
+    attributes: Dict[str, Any] = {}