agentspay 0.1.0 → 0.2.0

package/sdk-python/examples/consumer.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""
+AgentPay Consumer Example
+
+This example shows how to:
+1. Create a wallet
+2. Search for services
+3. Execute a service
+4. Handle disputes if needed
+"""
+
+from agentspay import AgentPayClient
+import json
+
+# Initialize client
+client = AgentPayClient(
+    base_url="http://localhost:3100",
+    # api_key="your-api-key"  # Optional API key
+)
+
+# Step 1: Create a wallet (or use existing one)
+print("Creating wallet...")
+wallet = client.create_wallet()
+print(f"✓ Wallet created: {wallet.id}")
+print(f"  Address: {wallet.address}")
+
+# Check balance
+balance_bsv = client.get_balance(wallet.id, currency="BSV")
+balance_mnee = client.get_balance(wallet.id, currency="MNEE")
+print(f"  Balance: {balance_bsv} satoshis (BSV), {balance_mnee} cents (MNEE)")
+
+# Step 2: Search for services
+print("\n" + "="*60)
+print("Searching for NLP services...")
+print("="*60)
+
+services = client.search_services(
+    keyword="nlp",
+    category="nlp",
+    max_price=5000,  # Max 5000 satoshis
+    limit=5
+)
+
+if not services:
+    print("No services found. Make sure there are registered services.")
+    exit(1)
+
+print(f"\nFound {len(services)} services:\n")
+for i, service in enumerate(services, 1):
+    print(f"{i}. {service.name}")
+    print(f"   Description: {service.description}")
+    print(f"   Price: {service.price} satoshis ({service.currency})")
+    print(f"   Category: {service.category}")
+    print(f"   Provider: {service.agent_id}")
+    
+    # Check provider reputation
+    try:
+        reputation = client.get_reputation(service.agent_id)
+        print(f"   Rating: {reputation.rating}/5 ({reputation.total_jobs} jobs, "
+              f"{reputation.success_rate * 100:.1f}% success)")
+    except:
+        print(f"   Rating: No reputation data")
+    print()
+
+# Step 3: Execute a service
+print("="*60)
+print("Executing the first service...")
+print("="*60)
+
+selected_service = services[0]
+print(f"\nService: {selected_service.name}")
+print(f"Price: {selected_service.price} satoshis")
+
+# Execute with input data
+try:
+    result = client.execute(
+        service_id=selected_service.id,
+        buyer_wallet_id=wallet.id,
+        input_data={
+            "text": "AgentPay is a decentralized marketplace for AI agent services. "
+                   "It enables autonomous agents to discover, execute, and pay for "
+                   "services using Bitcoin SV."
+        }
+    )
+    
+    print(f"\n✓ Execution successful!")
+    print(f"  Payment ID: {result.payment_id}")
+    print(f"  Execution Time: {result.execution_time_ms}ms")
+    print(f"  Status: {result.status}")
+    
+    # Show output
+    print(f"\n  Output:")
+    print(json.dumps(result.output, indent=4))
+    
+    # Show receipt (cryptographic proof)
+    if result.receipt:
+        print(f"\n  Receipt ID: {result.receipt.id}")
+        print(f"  Input Hash: {result.receipt.input_hash}")
+        print(f"  Output Hash: {result.receipt.output_hash}")
+        print(f"  Receipt Hash: {result.receipt.receipt_hash}")
+        print(f"  Provider Signature: {result.receipt.provider_signature[:32]}...")
+        
+    # Show payment details
+    if result.payment:
+        payment = result.payment
+        print(f"\n  Payment Status: {payment.status}")
+        print(f"  Amount: {payment.amount} satoshis")
+        print(f"  Platform Fee: {payment.platform_fee} satoshis")
+        if payment.tx_id:
+            print(f"  Transaction ID: {payment.tx_id}")
+
+except Exception as e:
+    print(f"\n✗ Execution failed: {e}")
+    exit(1)
+
+# Step 4: Example of opening a dispute (if needed)
+print("\n" + "="*60)
+print("Dispute Example (not executing, just showing API)")
+print("="*60)
+print("""
+# If the output is not satisfactory, you can open a dispute:
+
+dispute = client.open_dispute(
+    payment_id=result.payment_id,
+    reason="Output quality does not meet expectations",
+    evidence="Expected sentiment analysis but got only keywords. "
+             "Screenshots: https://imgur.com/abc123"
+)
+
+# Add more evidence later if needed
+client.add_dispute_evidence(
+    dispute_id=dispute.id,
+    evidence="Additional evidence: server logs showing incorrect processing"
+)
+
+# Check dispute status
+dispute_status = client.get_dispute(dispute.id)
+print(f"Dispute status: {dispute_status.status}")
+print(f"Resolution: {dispute_status.resolution}")
+""")
+
+print("\n" + "="*60)
+print("Transaction Complete!")
+print("="*60)
+print(f"\nPayment ID: {result.payment_id}")
+print("You can use this payment ID to track the transaction,")
+print("open disputes, or retrieve the receipt at any time.")

package/sdk-python/examples/provider.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+AgentPay Provider Example
+
+This example shows how to:
+1. Create a wallet
+2. Register a service
+3. Handle incoming execution requests (conceptual)
+"""
+
+from agentspay import AgentPayClient
+
+# Initialize client
+client = AgentPayClient(
+    base_url="http://localhost:3100",
+    # api_key="your-api-key"  # Optional API key
+)
+
+# Step 1: Create a wallet for your agent
+print("Creating wallet...")
+wallet = client.create_wallet()
+print(f"✓ Wallet created: {wallet.id}")
+print(f"  Address: {wallet.address}")
+print(f"  Public Key: {wallet.public_key}")
+
+# Step 2: Register a service
+print("\nRegistering service...")
+service = client.register_service(
+    agent_id=wallet.id,
+    name="TextAnalyzer",
+    description="Advanced NLP text analysis service",
+    price=1000,  # 1000 satoshis per execution
+    currency="BSV",  # or "MNEE"
+    endpoint="https://my-agent.com/api/analyze",
+    category="nlp",
+    method="POST",
+    timeout=30,  # 30 seconds max execution time
+    dispute_window=30,  # 30 minutes dispute window
+    input_schema={
+        "type": "object",
+        "properties": {
+            "text": {"type": "string"}
+        },
+        "required": ["text"]
+    }
+)
+
+print(f"✓ Service registered: {service.id}")
+print(f"  Name: {service.name}")
+print(f"  Price: {service.price} satoshis")
+print(f"  Category: {service.category}")
+print(f"  Endpoint: {service.endpoint}")
+
+# Step 3: Check reputation (if you have previous transactions)
+try:
+    reputation = client.get_reputation(wallet.id)
+    print(f"\nReputation:")
+    print(f"  Rating: {reputation.rating}/5")
+    print(f"  Success Rate: {reputation.success_rate * 100:.1f}%")
+    print(f"  Total Jobs: {reputation.total_jobs}")
+except Exception as e:
+    print(f"\nNo reputation data yet: {e}")
+
+# Step 4: Set up webhook to receive notifications
+print("\nRegistering webhook...")
+try:
+    webhook = client.register_webhook(
+        url="https://my-agent.com/webhooks/agentpay",
+        events=[
+            "payment.escrowed",  # When payment is held in escrow
+            "payment.released",  # When payment is released to you
+            "dispute.opened",    # When a dispute is opened
+            "service.executed"   # When your service is executed
+        ]
+    )
+    print(f"✓ Webhook registered: {webhook.id}")
+    print(f"  URL: {webhook.url}")
+    print(f"  Events: {', '.join(webhook.events)}")
+except Exception as e:
+    print(f"✗ Webhook registration failed: {e}")
+
+print("\n" + "="*60)
+print("Your service is now live on AgentPay!")
+print("="*60)
+print(f"\nService ID: {service.id}")
+print(f"Wallet ID: {wallet.id}")
+print("\nConsumers can now discover and execute your service.")
+print("Make sure your endpoint is accessible and handles POST requests.")
+
+# Example: What your endpoint should implement
+print("\n" + "-"*60)
+print("Your service endpoint should implement:")
+print("-"*60)
+print("""
+POST /api/analyze
+Content-Type: application/json
+
+{
+  "executionId": "exec_123...",
+  "paymentId": "pay_456...",
+  "input": {
+    "text": "Sample text to analyze"
+  }
+}
+
+Response:
+{
+  "status": "success",
+  "output": {
+    "sentiment": "positive",
+    "keywords": ["sample", "text", "analyze"],
+    "language": "en"
+  },
+  "executionTimeMs": 245
+}
+""")

package/sdk-python/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentspay"
+version = "0.2.0"
+description = "Python SDK for AgentPay - AI agent service marketplace with cryptocurrency payments"
+readme = "README.md"
+authors = [
+    {name = "AgentsPay", email = "contact@agentspay.io"}
+]
+license = {text = "MIT"}
+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",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Office/Business :: Financial",
+]
+keywords = ["agentpay", "ai", "agents", "cryptocurrency", "bsv", "bitcoin", "payments", "marketplace"]
+requires-python = ">=3.8"
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "mypy>=1.0.0",
+    "ruff>=0.0.260",
+]
+
+[project.urls]
+Homepage = "https://github.com/agentspay/agentspay"
+Documentation = "https://docs.agentspay.io"
+Repository = "https://github.com/agentspay/agentspay"
+Issues = "https://github.com/agentspay/agentspay/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["agentspay*"]
+
+[tool.black]
+line-length = 100
+target-version = ['py38', 'py39', 'py310', 'py311']
+
+[tool.mypy]
+python_version = "3.8"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false

package/sdk-python/setup.py

@@ -0,0 +1,53 @@
+"""Setup script for agentspay package"""
+
+from setuptools import setup, find_packages
+
+# Read the long description from README.md
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="agentspay",
+    version="0.2.0",
+    author="AgentsPay",
+    author_email="contact@agentspay.io",
+    description="Python SDK for AgentPay - AI agent service marketplace with cryptocurrency payments",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/agentspay/agentspay",
+    project_urls={
+        "Bug Tracker": "https://github.com/agentspay/agentspay/issues",
+        "Documentation": "https://docs.agentspay.io",
+        "Source Code": "https://github.com/agentspay/agentspay",
+    },
+    packages=find_packages(exclude=["tests", "tests.*", "examples", "examples.*"]),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Internet :: WWW/HTTP",
+        "Topic :: Office/Business :: Financial",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "requests>=2.28.0",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=7.0.0",
+            "pytest-cov>=4.0.0",
+            "black>=23.0.0",
+            "mypy>=1.0.0",
+            "ruff>=0.0.260",
+        ],
+    },
+    keywords="agentpay ai agents cryptocurrency bsv bitcoin payments marketplace",
+)

package/sdk-python/tests/test_client.py

@@ -0,0 +1,221 @@
+"""Tests for AgentPay SDK"""
+
+import pytest
+from unittest.mock import Mock, patch
+from agentspay import AgentPayClient
+from agentspay.exceptions import WalletError, ServiceError, ExecutionError
+
+
+class TestAgentPayClient:
+    """Test suite for AgentPayClient"""
+    
+    def test_client_initialization(self):
+        """Test client initializes with correct defaults"""
+        client = AgentPayClient()
+        assert client.base_url == "http://localhost:3100"
+        assert client.api_key is None
+        
+        client_with_key = AgentPayClient(
+            base_url="https://api.agentspay.io",
+            api_key="test-key"
+        )
+        assert client_with_key.base_url == "https://api.agentspay.io"
+        assert client_with_key.api_key == "test-key"
+    
+    @patch('agentspay.wallet.requests.post')
+    def test_create_wallet(self, mock_post):
+        """Test wallet creation"""
+        # Mock API response
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "wallet": {
+                "id": "wallet_123",
+                "publicKey": "pub_key_abc",
+                "address": "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
+                "createdAt": "2026-02-14T12:00:00Z",
+                "balance": 100000,
+                "balanceMnee": 5000
+            }
+        }
+        mock_response.raise_for_status = Mock()
+        mock_post.return_value = mock_response
+        
+        # Test
+        client = AgentPayClient()
+        wallet = client.create_wallet()
+        
+        assert wallet.id == "wallet_123"
+        assert wallet.public_key == "pub_key_abc"
+        assert wallet.address == "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
+        assert wallet.balance == 100000
+        assert wallet.balance_mnee == 5000
+    
+    @patch('agentspay.wallet.requests.get')
+    def test_get_wallet(self, mock_get):
+        """Test getting wallet by ID"""
+        # Mock API response
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "wallet": {
+                "id": "wallet_123",
+                "publicKey": "pub_key_abc",
+                "address": "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
+                "createdAt": "2026-02-14T12:00:00Z",
+                "balance": 50000
+            }
+        }
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+        
+        # Test
+        client = AgentPayClient()
+        wallet = client.get_wallet("wallet_123")
+        
+        assert wallet.id == "wallet_123"
+        assert wallet.balance == 50000
+    
+    @patch('agentspay.services.requests.post')
+    def test_register_service(self, mock_post):
+        """Test service registration"""
+        # Mock API response
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "service": {
+                "id": "service_456",
+                "agentId": "wallet_123",
+                "name": "TextAnalyzer",
+                "description": "NLP service",
+                "category": "nlp",
+                "price": 1000,
+                "currency": "BSV",
+                "endpoint": "https://agent.com/analyze",
+                "method": "POST",
+                "active": True,
+                "timeout": 30,
+                "disputeWindow": 30,
+                "createdAt": "2026-02-14T12:00:00Z",
+                "updatedAt": "2026-02-14T12:00:00Z"
+            }
+        }
+        mock_response.raise_for_status = Mock()
+        mock_post.return_value = mock_response
+        
+        # Test
+        client = AgentPayClient()
+        service = client.register_service(
+            agent_id="wallet_123",
+            name="TextAnalyzer",
+            description="NLP service",
+            price=1000,
+            currency="BSV",
+            endpoint="https://agent.com/analyze",
+            category="nlp"
+        )
+        
+        assert service.id == "service_456"
+        assert service.name == "TextAnalyzer"
+        assert service.price == 1000
+        assert service.currency == "BSV"
+        assert service.active is True
+    
+    @patch('agentspay.services.requests.get')
+    def test_search_services(self, mock_get):
+        """Test searching for services"""
+        # Mock API response
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "services": [
+                {
+                    "id": "service_1",
+                    "agentId": "wallet_1",
+                    "name": "Service 1",
+                    "description": "Test service",
+                    "category": "nlp",
+                    "price": 500,
+                    "currency": "BSV",
+                    "endpoint": "https://agent.com/1",
+                    "method": "POST",
+                    "active": True,
+                    "timeout": 30,
+                    "disputeWindow": 30,
+                    "createdAt": "2026-02-14T12:00:00Z",
+                    "updatedAt": "2026-02-14T12:00:00Z"
+                }
+            ]
+        }
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+        
+        # Test
+        client = AgentPayClient()
+        services = client.search_services(keyword="nlp", max_price=1000)
+        
+        assert len(services) == 1
+        assert services[0].id == "service_1"
+        assert services[0].category == "nlp"
+    
+    @patch('agentspay.payments.requests.post')
+    def test_execute_service(self, mock_post):
+        """Test service execution"""
+        # Mock API response
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "paymentId": "payment_789",
+            "serviceId": "service_456",
+            "output": {
+                "result": "success",
+                "data": "analyzed"
+            },
+            "executionTimeMs": 250,
+            "status": "success"
+        }
+        mock_response.raise_for_status = Mock()
+        mock_post.return_value = mock_response
+        
+        # Test
+        client = AgentPayClient()
+        result = client.execute(
+            service_id="service_456",
+            buyer_wallet_id="wallet_123",
+            input_data={"text": "Test"}
+        )
+        
+        assert result.payment_id == "payment_789"
+        assert result.service_id == "service_456"
+        assert result.status == "success"
+        assert result.execution_time_ms == 250
+        assert result.output["result"] == "success"
+
+
+class TestExceptions:
+    """Test SDK exceptions"""
+    
+    @patch('agentspay.wallet.requests.post')
+    def test_wallet_error(self, mock_post):
+        """Test WalletError is raised on API failure"""
+        mock_post.side_effect = Exception("Network error")
+        
+        client = AgentPayClient()
+        with pytest.raises(WalletError):
+            client.create_wallet()
+    
+    @patch('agentspay.services.requests.post')
+    def test_service_error(self, mock_post):
+        """Test ServiceError is raised on API failure"""
+        mock_post.side_effect = Exception("API error")
+        
+        client = AgentPayClient()
+        with pytest.raises(ServiceError):
+            client.register_service(
+                agent_id="wallet_123",
+                name="Test",
+                description="Test",
+                price=100,
+                currency="BSV",
+                endpoint="https://test.com",
+                category="test"
+            )
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

package/test-addr.js

@@ -0,0 +1,29 @@
+const { PrivateKey, Hash, Utils } = require('@bsv/sdk')
+const crypto = require('crypto')
+
+const pk = PrivateKey.fromRandom()
+const pub = pk.toPublicKey()
+
+// Mainnet
+console.log('Mainnet:', pub.toAddress())
+
+// Testnet - manual P2PKH with 0x6f prefix
+const pubEncoded = pub.encode(true)
+const hash160 = Hash.hash160(pubEncoded)
+const prefix = Uint8Array.from([0x6f])
+const payload = new Uint8Array(prefix.length + hash160.length)
+payload.set(prefix, 0)
+payload.set(hash160, prefix.length)
+const checksum = Hash.hash256(payload).slice(0, 4)
+const full = new Uint8Array(payload.length + checksum.length)
+full.set(payload, 0)
+full.set(checksum, payload.length)
+console.log('Testnet:', Utils.toBase58(full))
+console.log('WIF:', pk.toWif())
+
+// Also check toAddress with network param
+try {
+  console.log('toAddress testnet:', pub.toAddress('testnet'))
+} catch(e) {
+  console.log('toAddress testnet not supported:', e.message)
+}

package/test-mnee-simple.js

@@ -0,0 +1,51 @@
+// Simple MNEE test without database
+const { CurrencyManager } = require('./dist/currency/currency')
+
+async function test() {
+  console.log('🧪 Testing MNEE Currency Manager\n')
+
+  console.log('✅ Currency Configuration:')
+  console.log('  BSV:', JSON.stringify(CurrencyManager.getConfig('BSV'), null, 2))
+  console.log('  MNEE:', JSON.stringify(CurrencyManager.getConfig('MNEE'), null, 2))
+
+  console.log('\n✅ Amount Validation:')
+  console.log('  1000 sats (BSV):', CurrencyManager.validateAmount(1000, 'BSV'))
+  console.log('  150 cents (MNEE):', CurrencyManager.validateAmount(150, 'MNEE'))
+  console.log('  -10 cents (MNEE):', CurrencyManager.validateAmount(-10, 'MNEE'))
+  console.log('  0.5 cents (MNEE):', CurrencyManager.validateAmount(0.5, 'MNEE'))
+
+  console.log('\n✅ Formatting:')
+  console.log('  50000000 sats →', CurrencyManager.format(50000000, 'BSV'))
+  console.log('  1000 sats →', CurrencyManager.format(1000, 'BSV'))
+  console.log('  150 cents →', CurrencyManager.format(150, 'MNEE'))
+  console.log('  5000 cents →', CurrencyManager.format(5000, 'MNEE'))
+  console.log('  1 cent →', CurrencyManager.format(1, 'MNEE'))
+
+  console.log('\n✅ Fee Calculation (2%):')
+  console.log('  10000 sats BSV fee:', CurrencyManager.calculateFee(10000, 'BSV'), 'sats')
+  console.log('  1000 cents MNEE fee:', CurrencyManager.calculateFee(1000, 'MNEE'), 'cents ($0.20)')
+  console.log('  100 cents MNEE fee:', CurrencyManager.calculateFee(100, 'MNEE'), 'cents ($0.02)')
+  console.log('  10 cents MNEE fee:', CurrencyManager.calculateFee(10, 'MNEE'), 'cents (min 1 cent)')
+
+  console.log('\n✅ Parsing:')
+  console.log('  "1.50 MNEE" →', CurrencyManager.parse('1.50 MNEE', 'MNEE'), 'cents')
+  console.log('  "0.00001 BSV" →', CurrencyManager.parse('0.00001 BSV', 'BSV'), 'sats')
+  console.log('  "100.00" MNEE →', CurrencyManager.parse('100.00', 'MNEE'), 'cents')
+
+  console.log('\n✅ Conversion Rates:')
+  const bsvToMnee = await CurrencyManager.getConversionRate('BSV', 'MNEE')
+  const mneeToBsv = await CurrencyManager.getConversionRate('MNEE', 'BSV')
+  console.log('  1 sat =', bsvToMnee.rate.toFixed(6), 'MNEE cents')
+  console.log('  1 MNEE cent =', mneeToBsv.rate.toFixed(2), 'sats')
+  console.log('  Source:', bsvToMnee.source)
+
+  console.log('\n✅ Conversion Examples:')
+  const satsToCents = await CurrencyManager.convert(10000, 'BSV', 'MNEE')
+  console.log('  10000 sats ≈', satsToCents, 'cents ($' + (satsToCents/100).toFixed(2) + ')')
+  const centsToSats = await CurrencyManager.convert(100, 'MNEE', 'BSV')
+  console.log('  100 cents ($1) ≈', centsToSats, 'sats')
+
+  console.log('\n🎉 All currency manager tests passed!')
+}
+
+test().catch(console.error)