Payments for AI Agents & Bots

# Step 1: Generate agent wallet
solana-keygen new -o agent-wallet.json --no-bip39-passphrase

# Step 2: Get wallet address
AGENT_WALLET=$(solana-keygen pubkey agent-wallet.json)
echo "Agent wallet: $AGENT_WALLET"

# Step 3: Get unsigned escrow deposit transaction
curl -X POST https://shadow.radr.fun/shadowpay/api/escrow/deposit \
  -H "Content-Type: application/json" \
  -d "{
    \"wallet_address\": \"$AGENT_WALLET\",
    \"amount\": 100000000
  }" > escrow_tx.json

# Response contains unsigned transaction:
# {
#   "unsigned_tx_base64": "...",
#   "recent_blockhash": "..."
# }

# Step 4: Sign and send transaction (Python example)
python3 << 'EOF'
import json
import base64
from solders.keypair import Keypair
from solders.transaction import Transaction
from solana.rpc.api import Client

# Load agent wallet
with open('agent-wallet.json', 'r') as f:
    keypair_bytes = bytes(json.load(f))
agent_keypair = Keypair.from_bytes(keypair_bytes)

# Load unsigned transaction
with open('escrow_tx.json', 'r') as f:
    tx_data = json.load(f)

# Decode and sign transaction
tx_bytes = base64.b64decode(tx_data['unsigned_tx_base64'])
tx = Transaction.deserialize(tx_bytes)
tx.sign([agent_keypair])

# Send to Solana
client = Client('https://api.mainnet-beta.solana.com')
result = client.send_transaction(tx)
print(f"✅ Escrow funded! TX: {result.value}")
EOF

# Step 5: Verify escrow balance
curl https://shadow.radr.fun/shadowpay/api/escrow/balance/$AGENT_WALLET

import requests
import time
from shadowpay import ShadowPayClient

class AutonomousAgent:
    def __init__(self, wallet_address, escrow_balance):
        self.wallet = wallet_address
        self.shadowpay = ShadowPayClient(
            base_url='https://shadow.radr.fun'
        )
        self.escrow_balance = escrow_balance
    
    def fetch_premium_data(self, endpoint, merchant_wallet, 
                          merchant_api_key, amount):
        """
        Autonomously pay for and fetch data
        """
        try:
            # Step 1: Instant authorization (147ms)
            auth = self.shadowpay.authorize_payment(
                user_wallet=self.wallet,
                merchant_wallet=merchant_wallet,
                merchant_api_key=merchant_api_key,
                amount=amount
            )
            
            print(f"✅ Authorized: {auth['access_token'][:20]}...")
            
            # Step 2: Fetch data immediately
            response = requests.get(
                endpoint,
                headers={
                    'Authorization': f"Bearer {auth['access_token']}"
                }
            )
            
            if response.status_code == 200:
                data = response.json()
                
                # Step 3: Settle in background (non-blocking)
                self.shadowpay.settle_async(
                    commitment=auth['commitment'],
                    on_complete=lambda r: print(f"✅ Settled: {r['tx_hash']}")
                )
                
                return data
            else:
                print(f"❌ Failed to fetch: {response.status_code}")
                return None
                
        except Exception as e:
            print(f"❌ Payment error: {e}")
            return None
    
    def monitor_escrow_balance(self):
        """
        Check escrow balance and auto-refill
        """
        balance = self.shadowpay.get_escrow_balance(self.wallet)
        
        if balance < 1000000:  # Less than 0.001 SOL
            print("⚠️  Low escrow balance, refilling...")
            self.refill_escrow()
    
    def refill_escrow(self):
        """
        Automatically refill escrow when low
        """
        deposit = self.shadowpay.deposit_to_escrow(
            user_wallet=self.wallet,
            amount=50000000  # 0.05 SOL
        )
        print(f"✅ Escrow refilled: {deposit['tx_hash']}")

import subprocess
import json
import os

class ZKProofGenerator:
    def __init__(self, circuit_dir='./circuits'):
        """
        Initialize ZK proof generator with circuit artifacts
        """
        self.circuit_dir = circuit_dir
        self.ensure_circuits_downloaded()
    
    def ensure_circuits_downloaded(self):
        """
        Download circuit artifacts if not present
        """
        if not os.path.exists(self.circuit_dir):
            os.makedirs(self.circuit_dir)
        
        circuits = [
            'shadowpay_final.zkey',
            'shadowpay_js/shadowpay.wasm',
            'shadowpay-elgamal_final.zkey',
            'shadowpay-elgamal_js/shadowpay-elgamal.wasm'
        ]
        
        for circuit in circuits:
            if not os.path.exists(f"{self.circuit_dir}/{circuit}"):
                print(f"⚠️  Circuit {circuit} not found. Downloading...")
                # Download from CDN
                url = f"https://shadow.radr.fun/shadowpay/circuit/{circuit}"
                subprocess.run(['curl', '-o', f"{self.circuit_dir}/{circuit}", url])
    
    def generate_proof(self, witness_input):
        """
        Generate ZK proof by calling Node.js snarkjs subprocess
        
        NOTE: This requires Node.js and snarkjs installed:
        npm install -g snarkjs
        """
        # Write witness input to temp file
        with open('/tmp/witness_input.json', 'w') as f:
            json.dump(witness_input, f)
        
        # Call snarkjs via subprocess (blocks for ~2-5 seconds)
        proof_script = """
        const snarkjs = require('snarkjs');
        const fs = require('fs');
        
        async function generateProof() {
            const input = JSON.parse(fs.readFileSync('/tmp/witness_input.json'));
            
            const { proof, publicSignals } = await snarkjs.groth16.fullProve(
                input,
                './circuits/shadowpay_js/shadowpay.wasm',
                './circuits/shadowpay_final.zkey'
            );
            
            console.log(JSON.stringify({ proof, publicSignals }));
        }
        
        generateProof();
        """
        
        with open('/tmp/proof_gen.js', 'w') as f:
            f.write(proof_script)
        
        result = subprocess.run(
            ['node', '/tmp/proof_gen.js'],
            capture_output=True,
            text=True,
            timeout=10
        )
        
        if result.returncode == 0:
            return json.loads(result.stdout)
        else:
            raise Exception(f"Proof generation failed: {result.stderr}")

# Example usage in agent
zkp = ZKProofGenerator()

# Generate proof for payment
proof_data = zkp.generate_proof({
    'commitment': '12345678901234567890',
    'nullifier': '09876543210987654321',
    'amount': 1000000,
    'merkleRoot': '...',
    'merkleProofSiblings': [...]
})

print(f"✅ Proof generated: {proof_data['proof'][:50]}...")

# Usage
agent = AutonomousAgent(
    wallet_address='AGENT_WALLET_ADDRESS',
    escrow_balance=100000000
)

# Agent autonomously pays for data every 5 minutes
while True:
    data = agent.fetch_premium_data(
        endpoint='https://api.example.com/market-data',
        merchant_wallet='MERCHANT_WALLET',
        merchant_api_key='MERCHANT_API_KEY',
        amount=10000  # 0.00001 SOL per request
    )
    
    if data:
        print(f"📊 Market data: {data}")
    
    agent.monitor_escrow_balance()
    time.sleep(300)