foundry-client 1.0.0__tar.gz

foundry_client-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FoundryNet
+
+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.

foundry_client-1.0.0/PKG-INFO

@@ -0,0 +1,311 @@
+Metadata-Version: 2.4
+Name: foundry-client
+Version: 1.0.0
+Summary: Python client for FoundryNet - Universal DePIN Protocol for Work Settlement
+Home-page: https://github.com/foundrynet/foundry_net_MINT
+Author: FoundryNet
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyNaCl>=1.5.0
+Requires-Dist: base58>=2.1.1
+Requires-Dist: requests>=2.31.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+FoundryNet
+Earn MINT tokens for verified manufacturing work.
+FoundryNet rewards 3D printers, CNC machines, robots, and production equipment with cryptocurrency for completing jobs. No staking, no capital required—just connect your machine and start earning.
+
+Quick Start
+Installation
+bashnpm install tweetnacl bs58 uuid
+Download foundry-client.js from the GitHub repository.
+Basic Usage
+javascriptimport { FoundryClient } from './foundry-client.js';
+
+// Initialize client
+const client = new FoundryClient({ 
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts',
+  debug: true 
+});
+
+// Register machine (first time only - saves credentials locally)
+await client.init({ 
+  type: '3d-printer', 
+  model: 'Ender 3' 
+});
+
+// Start a job
+const jobHash = client.generateJobHash('benchy.gcode');
+await client.submitJob(jobHash, { 
+  job_type: 'print',
+  filename: 'benchy.gcode' 
+});
+
+// Complete job and earn MINT
+const result = await client.completeJob(
+  jobHash, 
+  'YOUR_SOLANA_WALLET_ADDRESS'
+);
+
+console.log(`Earned ${result.reward} MINT!`);
+console.log(`View transaction: ${result.solscan}`);
+That's it. Your machine is now earning.
+
+How It Works
+1. Register Your Machine
+Connect any machine that can make HTTP requests and sign messages (ed25519).
+Supported:
+
+3D Printers (OctoPrint, Klipper, Marlin)
+CNC Mills/Routers (GRBL, LinuxCNC)
+Laser Cutters
+Pick-and-Place Robots
+Custom DIY machines
+
+2. Submit Jobs
+When your machine starts productive work:
+javascriptconst jobHash = client.generateJobHash('my_part.gcode');
+await client.submitJob(jobHash, {
+  job_type: 'print',
+  filename: 'benchy.gcode'
+});
+3. Earn MINT
+When work completes successfully:
+javascriptawait client.completeJob(jobHash, yourSolanaWallet);
+// Instant payout: 3 MINT per job
+Current Rewards:
+
+3 MINT per completed job
+Maximum 400 MINT per machine per 24 hours
+Jobs must run minimum 60 seconds
+
+
+Integration Examples
+OctoPrint Plugin
+pythonfrom foundrynet import FoundryClient
+
+# In plugin initialization
+client = FoundryClient(api_url='https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts')
+client.init(metadata={'type': 'printer', 'model': 'Prusa MK3'})
+
+# On print start
+def on_print_started(filename):
+    job_hash = client.generate_job_hash(filename)
+    client.submit_job(job_hash, {'filename': filename})
+    
+# On print complete
+def on_print_done(job_hash):
+    client.complete_job(job_hash, user_wallet)
+Klipper/Moonraker
+python# Listen to Moonraker webhooks
+def on_print_started(data):
+    job_hash = client.generate_job_hash(data['filename'])
+    client.submit_job(job_hash, {'filename': data['filename']})
+
+def on_print_complete(data):
+    client.complete_job(current_job_hash, user_wallet)
+GRBL/CNC
+javascript// On program start
+const jobHash = client.generateJobHash(programName);
+await client.submitJob(jobHash, { 
+  job_type: 'cnc', 
+  program: programName 
+});
+
+// On program complete (M2/M30)
+await client.completeJob(jobHash, wallet);
+Custom/DIY
+javascript// Your machine, your rules
+const client = new FoundryClient({
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts'
+});
+
+await client.init({ 
+  type: 'custom', 
+  model: 'Pick and Place Robot' 
+});
+
+// When task starts
+const jobHash = client.generateJobHash(taskId);
+await client.submitJob(jobHash, {
+  job_type: 'robot',
+  task_id: taskId
+});
+
+// When task completes
+await client.completeJob(jobHash, wallet);
+
+API Reference
+FoundryClient(config)
+javascriptconst client = new FoundryClient({
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts',
+  retryAttempts: 3,      // Network retry count
+  retryDelay: 2000,      // ms between retries
+  debug: false           // Enable verbose logging
+});
+client.init(metadata)
+Initialize machine. Loads existing credentials or generates new ones.
+javascriptawait client.init({
+  type: 'printer',       // printer|cnc|robot|laser|custom
+  model: 'Ender 3 V2',
+  firmware: 'Klipper'
+});
+// Saves credentials to .foundry_credentials.json
+Returns:
+javascript{
+  existing: true,           // Whether credentials already existed
+  machineUuid: "abc-123",   // Your machine ID
+  identity: {...}           // New credentials (if first time)
+}
+client.submitJob(jobHash, payload)
+Register job start.
+javascriptawait client.submitJob('job_unique_hash', {
+  job_type: 'print',
+  filename: 'part.gcode',
+  estimated_time: 3600
+});
+Returns:
+javascript{
+  success: true,
+  job_hash: "job_unique_hash"
+}
+client.completeJob(jobHash, recipientWallet)
+Complete job and earn MINT.
+javascriptconst result = await client.completeJob(
+  'job_unique_hash',
+  'YOUR_SOLANA_WALLET_ADDRESS'
+);
+Returns:
+javascript{
+  success: true,
+  reward: 3,
+  tx_signature: "5x7y...",
+  solscan: "https://solscan.io/tx/..."
+}
+client.generateJobHash(filename, additionalData)
+Generate deterministic job hash.
+javascriptconst jobHash = client.generateJobHash('benchy.gcode');
+// Returns: "job_abc123_1234567890"
+
+Rules & Limits
+
+3 MINT per completed job
+400 MINT maximum per machine per 24 hours
+Jobs must run minimum 60 seconds
+Each job hash must be unique (no replays)
+Signature timestamp must be within 5 minutes
+
+What Counts as a Job?
+Any discrete unit of productive work:
+
+One 3D print from start to finish
+One CNC machining operation
+One robot task cycle
+One laser cut/engrave job
+
+What Doesn't Count?
+
+Machine idle time
+Calibration/homing
+Test runs
+Failed or cancelled jobs
+
+
+Security
+Proof of Productivity (PoP)
+Every job completion requires:
+
+Unique job hash (prevents replay attacks)
+Ed25519 signature from registered machine keypair
+Recent timestamp (within 5 minutes)
+Minimum duration (60 seconds)
+Rate limiting (400 MINT/24hrs per machine)
+
+Your Machine Keys
+
+Generated locally on first init()
+Stored in .foundry_credentials.json
+Never leave your machine
+Back them up securely
+
+Anti-Fraud
+
+Job hash uniqueness enforced
+Signature verification prevents impersonation
+Rate limits prevent spam
+Duration checks prevent instant gaming
+
+
+Troubleshooting
+"Job completion failed"
+
+Check your machine credentials are loaded (client.init())
+Verify job was submitted before completing
+Ensure wallet address is valid Solana address
+
+"Rate limit exceeded"
+
+You've earned 400 MINT in the last 24 hours
+Wait for the rolling window to reset
+Check dashboard for current limits
+
+"Signature verification failed"
+
+Machine credentials may be corrupted
+Delete .foundry_credentials.json and re-run init()
+Ensure system time is accurate (for timestamps)
+
+"Job duration too short"
+
+Jobs must run minimum 60 seconds
+Ensure you're measuring actual work time
+Don't complete jobs immediately after starting
+
+"Treasury depleted"
+
+System maintenance in progress
+Jobs are queued and will process when treasury refills
+Check status updates
+
+
+Getting a Wallet?
+New to crypto? 
+Here's how to receive MINT:
+
+Install Phantom Wallet (browser extension)
+Create new wallet
+Copy your Solana address
+Use that address in completeJob()
+
+MINT tokens appear instantly in your wallet after job completion.
+
+Vision
+FoundryNet is building payment infrastructure for autonomous industry.
+We're starting simple: machines prove work happened, get paid instantly. The protocol handles identity, verification, and settlement. Everything else such as quality systems, marketplaces, reputation—gets built on top.
+This is infrastructure for when AI agents coordinate supply chains and manufacturing capacity becomes programmable.
+
+Tokenomics
+Token: MINT (Solana SPL token)
+Contract: 84hLMyG9cnC3Pd9LrWn4NtKMEhQHh4AvxbkcDMQtgem
+
+
+Initial treasury funded by protocol creator
+Rewards distributed for completed jobs
+LP available on Raydium (MINT/SOL)

foundry_client-1.0.0/README.md

@@ -0,0 +1,281 @@
+FoundryNet
+Earn MINT tokens for verified manufacturing work.
+FoundryNet rewards 3D printers, CNC machines, robots, and production equipment with cryptocurrency for completing jobs. No staking, no capital required—just connect your machine and start earning.
+
+Quick Start
+Installation
+bashnpm install tweetnacl bs58 uuid
+Download foundry-client.js from the GitHub repository.
+Basic Usage
+javascriptimport { FoundryClient } from './foundry-client.js';
+
+// Initialize client
+const client = new FoundryClient({ 
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts',
+  debug: true 
+});
+
+// Register machine (first time only - saves credentials locally)
+await client.init({ 
+  type: '3d-printer', 
+  model: 'Ender 3' 
+});
+
+// Start a job
+const jobHash = client.generateJobHash('benchy.gcode');
+await client.submitJob(jobHash, { 
+  job_type: 'print',
+  filename: 'benchy.gcode' 
+});
+
+// Complete job and earn MINT
+const result = await client.completeJob(
+  jobHash, 
+  'YOUR_SOLANA_WALLET_ADDRESS'
+);
+
+console.log(`Earned ${result.reward} MINT!`);
+console.log(`View transaction: ${result.solscan}`);
+That's it. Your machine is now earning.
+
+How It Works
+1. Register Your Machine
+Connect any machine that can make HTTP requests and sign messages (ed25519).
+Supported:
+
+3D Printers (OctoPrint, Klipper, Marlin)
+CNC Mills/Routers (GRBL, LinuxCNC)
+Laser Cutters
+Pick-and-Place Robots
+Custom DIY machines
+
+2. Submit Jobs
+When your machine starts productive work:
+javascriptconst jobHash = client.generateJobHash('my_part.gcode');
+await client.submitJob(jobHash, {
+  job_type: 'print',
+  filename: 'benchy.gcode'
+});
+3. Earn MINT
+When work completes successfully:
+javascriptawait client.completeJob(jobHash, yourSolanaWallet);
+// Instant payout: 3 MINT per job
+Current Rewards:
+
+3 MINT per completed job
+Maximum 400 MINT per machine per 24 hours
+Jobs must run minimum 60 seconds
+
+
+Integration Examples
+OctoPrint Plugin
+pythonfrom foundrynet import FoundryClient
+
+# In plugin initialization
+client = FoundryClient(api_url='https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts')
+client.init(metadata={'type': 'printer', 'model': 'Prusa MK3'})
+
+# On print start
+def on_print_started(filename):
+    job_hash = client.generate_job_hash(filename)
+    client.submit_job(job_hash, {'filename': filename})
+    
+# On print complete
+def on_print_done(job_hash):
+    client.complete_job(job_hash, user_wallet)
+Klipper/Moonraker
+python# Listen to Moonraker webhooks
+def on_print_started(data):
+    job_hash = client.generate_job_hash(data['filename'])
+    client.submit_job(job_hash, {'filename': data['filename']})
+
+def on_print_complete(data):
+    client.complete_job(current_job_hash, user_wallet)
+GRBL/CNC
+javascript// On program start
+const jobHash = client.generateJobHash(programName);
+await client.submitJob(jobHash, { 
+  job_type: 'cnc', 
+  program: programName 
+});
+
+// On program complete (M2/M30)
+await client.completeJob(jobHash, wallet);
+Custom/DIY
+javascript// Your machine, your rules
+const client = new FoundryClient({
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts'
+});
+
+await client.init({ 
+  type: 'custom', 
+  model: 'Pick and Place Robot' 
+});
+
+// When task starts
+const jobHash = client.generateJobHash(taskId);
+await client.submitJob(jobHash, {
+  job_type: 'robot',
+  task_id: taskId
+});
+
+// When task completes
+await client.completeJob(jobHash, wallet);
+
+API Reference
+FoundryClient(config)
+javascriptconst client = new FoundryClient({
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts',
+  retryAttempts: 3,      // Network retry count
+  retryDelay: 2000,      // ms between retries
+  debug: false           // Enable verbose logging
+});
+client.init(metadata)
+Initialize machine. Loads existing credentials or generates new ones.
+javascriptawait client.init({
+  type: 'printer',       // printer|cnc|robot|laser|custom
+  model: 'Ender 3 V2',
+  firmware: 'Klipper'
+});
+// Saves credentials to .foundry_credentials.json
+Returns:
+javascript{
+  existing: true,           // Whether credentials already existed
+  machineUuid: "abc-123",   // Your machine ID
+  identity: {...}           // New credentials (if first time)
+}
+client.submitJob(jobHash, payload)
+Register job start.
+javascriptawait client.submitJob('job_unique_hash', {
+  job_type: 'print',
+  filename: 'part.gcode',
+  estimated_time: 3600
+});
+Returns:
+javascript{
+  success: true,
+  job_hash: "job_unique_hash"
+}
+client.completeJob(jobHash, recipientWallet)
+Complete job and earn MINT.
+javascriptconst result = await client.completeJob(
+  'job_unique_hash',
+  'YOUR_SOLANA_WALLET_ADDRESS'
+);
+Returns:
+javascript{
+  success: true,
+  reward: 3,
+  tx_signature: "5x7y...",
+  solscan: "https://solscan.io/tx/..."
+}
+client.generateJobHash(filename, additionalData)
+Generate deterministic job hash.
+javascriptconst jobHash = client.generateJobHash('benchy.gcode');
+// Returns: "job_abc123_1234567890"
+
+Rules & Limits
+
+3 MINT per completed job
+400 MINT maximum per machine per 24 hours
+Jobs must run minimum 60 seconds
+Each job hash must be unique (no replays)
+Signature timestamp must be within 5 minutes
+
+What Counts as a Job?
+Any discrete unit of productive work:
+
+One 3D print from start to finish
+One CNC machining operation
+One robot task cycle
+One laser cut/engrave job
+
+What Doesn't Count?
+
+Machine idle time
+Calibration/homing
+Test runs
+Failed or cancelled jobs
+
+
+Security
+Proof of Productivity (PoP)
+Every job completion requires:
+
+Unique job hash (prevents replay attacks)
+Ed25519 signature from registered machine keypair
+Recent timestamp (within 5 minutes)
+Minimum duration (60 seconds)
+Rate limiting (400 MINT/24hrs per machine)
+
+Your Machine Keys
+
+Generated locally on first init()
+Stored in .foundry_credentials.json
+Never leave your machine
+Back them up securely
+
+Anti-Fraud
+
+Job hash uniqueness enforced
+Signature verification prevents impersonation
+Rate limits prevent spam
+Duration checks prevent instant gaming
+
+
+Troubleshooting
+"Job completion failed"
+
+Check your machine credentials are loaded (client.init())
+Verify job was submitted before completing
+Ensure wallet address is valid Solana address
+
+"Rate limit exceeded"
+
+You've earned 400 MINT in the last 24 hours
+Wait for the rolling window to reset
+Check dashboard for current limits
+
+"Signature verification failed"
+
+Machine credentials may be corrupted
+Delete .foundry_credentials.json and re-run init()
+Ensure system time is accurate (for timestamps)
+
+"Job duration too short"
+
+Jobs must run minimum 60 seconds
+Ensure you're measuring actual work time
+Don't complete jobs immediately after starting
+
+"Treasury depleted"
+
+System maintenance in progress
+Jobs are queued and will process when treasury refills
+Check status updates
+
+
+Getting a Wallet?
+New to crypto? 
+Here's how to receive MINT:
+
+Install Phantom Wallet (browser extension)
+Create new wallet
+Copy your Solana address
+Use that address in completeJob()
+
+MINT tokens appear instantly in your wallet after job completion.
+
+Vision
+FoundryNet is building payment infrastructure for autonomous industry.
+We're starting simple: machines prove work happened, get paid instantly. The protocol handles identity, verification, and settlement. Everything else such as quality systems, marketplaces, reputation—gets built on top.
+This is infrastructure for when AI agents coordinate supply chains and manufacturing capacity becomes programmable.
+
+Tokenomics
+Token: MINT (Solana SPL token)
+Contract: 84hLMyG9cnC3Pd9LrWn4NtKMEhQHh4AvxbkcDMQtgem
+
+
+Initial treasury funded by protocol creator
+Rewards distributed for completed jobs
+LP available on Raydium (MINT/SOL)

foundry_client-1.0.0/foundry_client/__init__.py

@@ -0,0 +1,4 @@
+from .client import FoundryClient
+
+__version__ = "1.0.0"
+__all__ = ["FoundryClient"]

foundry_client-1.0.0/foundry_client/client.py

@@ -0,0 +1,262 @@
+import nacl.signing
+import nacl.encoding
+import base58
+import requests
+import json
+import hashlib
+import time
+import os
+from uuid import uuid4
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, Dict, Any
+
+class FoundryClient:
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        config = config or {}
+        self.api_url = config.get('api_url', 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts')
+        self.retry_attempts = config.get('retry_attempts', 3)
+        self.retry_delay = config.get('retry_delay', 2.0)
+        self.debug = config.get('debug', False)
+        self.credentials_file = config.get('credentials_file', '.foundry_credentials.json')
+        
+        self.machine_uuid: Optional[str] = None
+        self.signing_key: Optional[nacl.signing.SigningKey] = None
+        self.verify_key: Optional[nacl.signing.VerifyKey] = None
+    
+    def log(self, level: str, message: str, data: Optional[Dict] = None):
+        if not self.debug and level == 'debug':
+            return
+        timestamp = datetime.utcnow().isoformat()
+        print(f"[FoundryNet {timestamp}] [{level.upper()}] {message}", data or {})
+    
+    def _retry(self, fn, context: str = ''):
+        last_error = None
+        for attempt in range(1, self.retry_attempts + 1):
+            try:
+                return fn()
+            except Exception as error:
+                last_error = error
+                self.log('warn', f"{context} failed (attempt {attempt}/{self.retry_attempts})", 
+                        {'error': str(error)})
+                if attempt < self.retry_attempts:
+                    delay = self.retry_delay * attempt
+                    self.log('debug', f"Retrying in {delay}s...")
+                    time.sleep(delay)
+        
+        self.log('error', f"{context} failed after {self.retry_attempts} attempts", 
+                {'error': str(last_error)})
+        raise last_error
+    
+    def generate_machine_id(self) -> Dict[str, str]:
+        self.machine_uuid = str(uuid4())
+        self.signing_key = nacl.signing.SigningKey.generate()
+        self.verify_key = self.signing_key.verify_key
+        
+        identity = {
+            'machine_uuid': self.machine_uuid,
+            'public_key': base58.b58encode(bytes(self.verify_key)).decode('utf-8'),
+            'secret_key': base58.b58encode(bytes(self.signing_key)).decode('utf-8'),
+        }
+        
+        self.log('info', 'Generated new machine identity', {
+            'machine_uuid': identity['machine_uuid'],
+            'public_key': identity['public_key'],
+        })
+        return identity
+    
+    def load_machine_id(self, machine_uuid: str, secret_key_base58: str):
+        try:
+            self.machine_uuid = machine_uuid
+            secret_key_bytes = base58.b58decode(secret_key_base58)
+            self.signing_key = nacl.signing.SigningKey(secret_key_bytes)
+            self.verify_key = self.signing_key.verify_key
+            self.log('info', 'Loaded machine identity', {'machine_uuid': machine_uuid})
+        except Exception as error:
+            self.log('error', 'Failed to load machine identity', {'error': str(error)})
+            raise ValueError(f"Invalid machine credentials: {error}")
+    
+    def save_credentials(self, identity: Dict[str, str]):
+        cred_path = Path.cwd() / self.credentials_file
+        credentials = {
+            'machine_uuid': identity['machine_uuid'],
+            'secret_key': identity['secret_key'],
+            'public_key': identity['public_key'],
+            'created_at': datetime.utcnow().isoformat(),
+        }
+        with open(cred_path, 'w') as f:
+            json.dump(credentials, f, indent=2)
+        self.log('debug', 'Credentials saved', {'file': str(cred_path)})
+    
+    def load_credentials(self) -> bool:
+        try:
+            cred_path = Path.cwd() / self.credentials_file
+            if cred_path.exists():
+                with open(cred_path, 'r') as f:
+                    creds = json.load(f)
+                self.load_machine_id(creds['machine_uuid'], creds['secret_key'])
+                self.log('info', 'Loaded existing credentials', 
+                        {'machine_uuid': self.machine_uuid})
+                return True
+        except Exception:
+            self.log('debug', 'No existing credentials found or corrupted')
+        return False
+    
+    def init(self, metadata: Optional[Dict] = None) -> Dict[str, Any]:
+        metadata = metadata or {}
+        
+        if self.load_credentials():
+            self.log('info', 'Using existing machine credentials', 
+                    {'machine_uuid': self.machine_uuid})
+            return {'existing': True, 'machine_uuid': self.machine_uuid}
+        
+        identity = self.generate_machine_id()
+        self.save_credentials(identity)
+        self.register_machine(metadata)
+        
+        return {
+            'existing': False,
+            'identity': identity,
+            'machine_uuid': self.machine_uuid
+        }
+    
+    def register_machine(self, metadata: Optional[Dict] = None) -> Dict:
+        metadata = metadata or {}
+        
+        if not self.machine_uuid or not self.verify_key:
+            raise ValueError('Generate or load machine ID first')
+        
+        def _register():
+            response = requests.post(
+                f"{self.api_url}/register-machine",
+                json={
+                    'machine_uuid': self.machine_uuid,
+                    'machine_pubkey_base58': base58.b58encode(bytes(self.verify_key)).decode('utf-8'),
+                    'metadata': metadata,
+                },
+                headers={'Content-Type': 'application/json'}
+            )
+            
+            if not response.ok:
+                raise Exception(f"Registration failed: {response.text}")
+            
+            result = response.json()
+            self.log('info', 'Machine registered successfully', 
+                    {'machine_uuid': self.machine_uuid})
+            return result
+        
+        return self._retry(_register, 'Machine registration')
+    
+    def submit_job(self, job_hash: str, complexity: float = 1.0, 
+                   payload: Optional[Dict] = None) -> Dict:
+        payload = payload or {}
+        
+        if not self.machine_uuid:
+            raise ValueError('Machine not initialized')
+        
+        normalized = round(complexity * 100) / 100
+        
+        MIN_COMPLEXITY = 0.5
+        MAX_COMPLEXITY = 2.0
+        TOLERANCE = 0.01
+        
+        if normalized < MIN_COMPLEXITY - TOLERANCE or normalized > MAX_COMPLEXITY + TOLERANCE:
+            raise ValueError(f"Complexity must be {MIN_COMPLEXITY}-{MAX_COMPLEXITY}, got {normalized}")
+        
+        def _submit():
+            response = requests.post(
+                f"{self.api_url}/submit-job",
+                json={
+                    'machine_uuid': self.machine_uuid,
+                    'job_hash': job_hash,
+                    'complexity': normalized,
+                    'payload': payload,
+                },
+                headers={'Content-Type': 'application/json'}
+            )
+            
+            if response.status_code == 409:
+                self.log('warn', 'Job already exists', {'job_hash': job_hash})
+                return {'success': True, 'duplicate': True, 'job_hash': job_hash}
+            
+            if not response.ok:
+                text = response.text
+                try:
+                    error = response.json().get('error', text)
+                except:
+                    error = text
+                raise Exception(f"Job submission failed: {error}")
+            
+            result = response.json()
+            self.log('debug', 'Job submitted', {'job_hash': job_hash, 'complexity': normalized})
+            return result
+        
+        return self._retry(_submit, 'Job submission')
+    
+    def complete_job(self, job_hash: str, recipient_wallet: str) -> Dict:
+        if not self.machine_uuid or not self.signing_key:
+            raise ValueError('Machine not initialized')
+        
+        timestamp = datetime.utcnow().isoformat()
+        message = f"{job_hash}|{recipient_wallet}|{timestamp}"
+        message_bytes = message.encode('utf-8')
+        
+        signed = self.signing_key.sign(message_bytes)
+        signature = signed.signature
+        
+        def _complete():
+            response = requests.post(
+                f"{self.api_url}/complete-job",
+                json={
+                    'machine_uuid': self.machine_uuid,
+                    'job_hash': job_hash,
+                    'recipient_wallet': recipient_wallet,
+                    'completion_proof': {
+                        'timestamp': timestamp,
+                        'signature_base58': base58.b58encode(signature).decode('utf-8'),
+                    },
+                },
+                headers={'Content-Type': 'application/json'}
+            )
+            
+            if not response.ok:
+                raise Exception(f"Job completion failed: {response.text}")
+            
+            result = response.json()
+            self.log('info', 'Job completed - MINT earned!', {
+                'job_hash': job_hash,
+                'reward': result.get('reward_net'),
+                'tx_signature': result.get('tx_signature'),
+                'activity_ratio': result.get('activity_ratio'),
+            })
+            return result
+        
+        return self._retry(_complete, 'Job completion')
+    
+    def generate_job_hash(self, filename: str, additional_data: str = '') -> str:
+        data = f"{self.machine_uuid}|{filename}|{int(time.time() * 1000)}|{additional_data}"
+        hash_obj = hashlib.sha256(data.encode('utf-8'))
+        hash_hex = hash_obj.hexdigest()
+        return f"job_{hash_hex[:16]}_{int(time.time() * 1000)}"
+    
+    def get_metrics(self) -> Dict:
+        def _fetch():
+            response = requests.get(
+                f"{self.api_url}/metrics",
+                headers={'Content-Type': 'application/json'}
+            )
+            
+            if not response.ok:
+                raise Exception("Failed to fetch metrics")
+            
+            return response.json()
+        
+        return self._retry(_fetch, 'Fetch metrics')
+    
+    def get_machine_uuid(self) -> str:
+        return self.machine_uuid or ''
+    
+    def get_public_key(self) -> str:
+        if self.verify_key:
+            return base58.b58encode(bytes(self.verify_key)).decode('utf-8')
+        return ''

foundry_client-1.0.0/foundry_client.egg-info/PKG-INFO

@@ -0,0 +1,311 @@
+Metadata-Version: 2.4
+Name: foundry-client
+Version: 1.0.0
+Summary: Python client for FoundryNet - Universal DePIN Protocol for Work Settlement
+Home-page: https://github.com/foundrynet/foundry_net_MINT
+Author: FoundryNet
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyNaCl>=1.5.0
+Requires-Dist: base58>=2.1.1
+Requires-Dist: requests>=2.31.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+FoundryNet
+Earn MINT tokens for verified manufacturing work.
+FoundryNet rewards 3D printers, CNC machines, robots, and production equipment with cryptocurrency for completing jobs. No staking, no capital required—just connect your machine and start earning.
+
+Quick Start
+Installation
+bashnpm install tweetnacl bs58 uuid
+Download foundry-client.js from the GitHub repository.
+Basic Usage
+javascriptimport { FoundryClient } from './foundry-client.js';
+
+// Initialize client
+const client = new FoundryClient({ 
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts',
+  debug: true 
+});
+
+// Register machine (first time only - saves credentials locally)
+await client.init({ 
+  type: '3d-printer', 
+  model: 'Ender 3' 
+});
+
+// Start a job
+const jobHash = client.generateJobHash('benchy.gcode');
+await client.submitJob(jobHash, { 
+  job_type: 'print',
+  filename: 'benchy.gcode' 
+});
+
+// Complete job and earn MINT
+const result = await client.completeJob(
+  jobHash, 
+  'YOUR_SOLANA_WALLET_ADDRESS'
+);
+
+console.log(`Earned ${result.reward} MINT!`);
+console.log(`View transaction: ${result.solscan}`);
+That's it. Your machine is now earning.
+
+How It Works
+1. Register Your Machine
+Connect any machine that can make HTTP requests and sign messages (ed25519).
+Supported:
+
+3D Printers (OctoPrint, Klipper, Marlin)
+CNC Mills/Routers (GRBL, LinuxCNC)
+Laser Cutters
+Pick-and-Place Robots
+Custom DIY machines
+
+2. Submit Jobs
+When your machine starts productive work:
+javascriptconst jobHash = client.generateJobHash('my_part.gcode');
+await client.submitJob(jobHash, {
+  job_type: 'print',
+  filename: 'benchy.gcode'
+});
+3. Earn MINT
+When work completes successfully:
+javascriptawait client.completeJob(jobHash, yourSolanaWallet);
+// Instant payout: 3 MINT per job
+Current Rewards:
+
+3 MINT per completed job
+Maximum 400 MINT per machine per 24 hours
+Jobs must run minimum 60 seconds
+
+
+Integration Examples
+OctoPrint Plugin
+pythonfrom foundrynet import FoundryClient
+
+# In plugin initialization
+client = FoundryClient(api_url='https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts')
+client.init(metadata={'type': 'printer', 'model': 'Prusa MK3'})
+
+# On print start
+def on_print_started(filename):
+    job_hash = client.generate_job_hash(filename)
+    client.submit_job(job_hash, {'filename': filename})
+    
+# On print complete
+def on_print_done(job_hash):
+    client.complete_job(job_hash, user_wallet)
+Klipper/Moonraker
+python# Listen to Moonraker webhooks
+def on_print_started(data):
+    job_hash = client.generate_job_hash(data['filename'])
+    client.submit_job(job_hash, {'filename': data['filename']})
+
+def on_print_complete(data):
+    client.complete_job(current_job_hash, user_wallet)
+GRBL/CNC
+javascript// On program start
+const jobHash = client.generateJobHash(programName);
+await client.submitJob(jobHash, { 
+  job_type: 'cnc', 
+  program: programName 
+});
+
+// On program complete (M2/M30)
+await client.completeJob(jobHash, wallet);
+Custom/DIY
+javascript// Your machine, your rules
+const client = new FoundryClient({
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts'
+});
+
+await client.init({ 
+  type: 'custom', 
+  model: 'Pick and Place Robot' 
+});
+
+// When task starts
+const jobHash = client.generateJobHash(taskId);
+await client.submitJob(jobHash, {
+  job_type: 'robot',
+  task_id: taskId
+});
+
+// When task completes
+await client.completeJob(jobHash, wallet);
+
+API Reference
+FoundryClient(config)
+javascriptconst client = new FoundryClient({
+  apiUrl: 'https://lsijwmklicmqtuqxhgnu.supabase.co/functions/v1/main-ts',
+  retryAttempts: 3,      // Network retry count
+  retryDelay: 2000,      // ms between retries
+  debug: false           // Enable verbose logging
+});
+client.init(metadata)
+Initialize machine. Loads existing credentials or generates new ones.
+javascriptawait client.init({
+  type: 'printer',       // printer|cnc|robot|laser|custom
+  model: 'Ender 3 V2',
+  firmware: 'Klipper'
+});
+// Saves credentials to .foundry_credentials.json
+Returns:
+javascript{
+  existing: true,           // Whether credentials already existed
+  machineUuid: "abc-123",   // Your machine ID
+  identity: {...}           // New credentials (if first time)
+}
+client.submitJob(jobHash, payload)
+Register job start.
+javascriptawait client.submitJob('job_unique_hash', {
+  job_type: 'print',
+  filename: 'part.gcode',
+  estimated_time: 3600
+});
+Returns:
+javascript{
+  success: true,
+  job_hash: "job_unique_hash"
+}
+client.completeJob(jobHash, recipientWallet)
+Complete job and earn MINT.
+javascriptconst result = await client.completeJob(
+  'job_unique_hash',
+  'YOUR_SOLANA_WALLET_ADDRESS'
+);
+Returns:
+javascript{
+  success: true,
+  reward: 3,
+  tx_signature: "5x7y...",
+  solscan: "https://solscan.io/tx/..."
+}
+client.generateJobHash(filename, additionalData)
+Generate deterministic job hash.
+javascriptconst jobHash = client.generateJobHash('benchy.gcode');
+// Returns: "job_abc123_1234567890"
+
+Rules & Limits
+
+3 MINT per completed job
+400 MINT maximum per machine per 24 hours
+Jobs must run minimum 60 seconds
+Each job hash must be unique (no replays)
+Signature timestamp must be within 5 minutes
+
+What Counts as a Job?
+Any discrete unit of productive work:
+
+One 3D print from start to finish
+One CNC machining operation
+One robot task cycle
+One laser cut/engrave job
+
+What Doesn't Count?
+
+Machine idle time
+Calibration/homing
+Test runs
+Failed or cancelled jobs
+
+
+Security
+Proof of Productivity (PoP)
+Every job completion requires:
+
+Unique job hash (prevents replay attacks)
+Ed25519 signature from registered machine keypair
+Recent timestamp (within 5 minutes)
+Minimum duration (60 seconds)
+Rate limiting (400 MINT/24hrs per machine)
+
+Your Machine Keys
+
+Generated locally on first init()
+Stored in .foundry_credentials.json
+Never leave your machine
+Back them up securely
+
+Anti-Fraud
+
+Job hash uniqueness enforced
+Signature verification prevents impersonation
+Rate limits prevent spam
+Duration checks prevent instant gaming
+
+
+Troubleshooting
+"Job completion failed"
+
+Check your machine credentials are loaded (client.init())
+Verify job was submitted before completing
+Ensure wallet address is valid Solana address
+
+"Rate limit exceeded"
+
+You've earned 400 MINT in the last 24 hours
+Wait for the rolling window to reset
+Check dashboard for current limits
+
+"Signature verification failed"
+
+Machine credentials may be corrupted
+Delete .foundry_credentials.json and re-run init()
+Ensure system time is accurate (for timestamps)
+
+"Job duration too short"
+
+Jobs must run minimum 60 seconds
+Ensure you're measuring actual work time
+Don't complete jobs immediately after starting
+
+"Treasury depleted"
+
+System maintenance in progress
+Jobs are queued and will process when treasury refills
+Check status updates
+
+
+Getting a Wallet?
+New to crypto? 
+Here's how to receive MINT:
+
+Install Phantom Wallet (browser extension)
+Create new wallet
+Copy your Solana address
+Use that address in completeJob()
+
+MINT tokens appear instantly in your wallet after job completion.
+
+Vision
+FoundryNet is building payment infrastructure for autonomous industry.
+We're starting simple: machines prove work happened, get paid instantly. The protocol handles identity, verification, and settlement. Everything else such as quality systems, marketplaces, reputation—gets built on top.
+This is infrastructure for when AI agents coordinate supply chains and manufacturing capacity becomes programmable.
+
+Tokenomics
+Token: MINT (Solana SPL token)
+Contract: 84hLMyG9cnC3Pd9LrWn4NtKMEhQHh4AvxbkcDMQtgem
+
+
+Initial treasury funded by protocol creator
+Rewards distributed for completed jobs
+LP available on Raydium (MINT/SOL)

foundry_client-1.0.0/foundry_client.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+setup.py
+foundry_client/__init__.py
+foundry_client/client.py
+foundry_client.egg-info/PKG-INFO
+foundry_client.egg-info/SOURCES.txt
+foundry_client.egg-info/dependency_links.txt
+foundry_client.egg-info/requires.txt
+foundry_client.egg-info/top_level.txt

foundry_client-1.0.0/foundry_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

foundry_client-1.0.0/foundry_client.egg-info/requires.txt

@@ -0,0 +1,3 @@
+PyNaCl>=1.5.0
+base58>=2.1.1
+requests>=2.31.0

foundry_client-1.0.0/foundry_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+foundry_client

foundry_client-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

foundry_client-1.0.0/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="foundry-client",
+    version="1.0.0",
+    author="FoundryNet",
+    description="Python client for FoundryNet - Universal DePIN Protocol for Work Settlement",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/foundrynet/foundry_net_MINT",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "PyNaCl>=1.5.0",
+        "base58>=2.1.1",
+        "requests>=2.31.0",
+    ],
+)