Implement x402

import { createWalletClient, http, parseUnits } from 'viem';
import { privateKeyToAccount } => 'viem/accounts';
import { base } from 'viem/chains';

const USDC_ADDRESS = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const ERC20_ABI = [{
  name: 'transfer',
  type: 'function',
  stateMutability: 'nonpayable',
  inputs: [
    { name: 'to', type: 'address' },
    { name: 'amount', type: 'uint256' }
  ],
  outputs: [{ name: '', type: 'bool' }]
}];

async function fetchWith402(url, privateKey) {
  // Initialize wallet
  const account = privateKeyToAccount(privateKey);
  const client = createWalletClient({
    account,
    chain: base,
    transport: http()
  });

  // 1. Initial request
  let res = await fetch(url);

  if (res.status === 402) {
    console.log('Payment Required');
    
    // 2. Parse payment details
    const auth = res.headers.get('WWW-Authenticate');
    const addressMatch = auth.match(/address="([^"]+)"/);
    const amountMatch = auth.match(/amount="([^"]+)"/);
    
    const recipient = addressMatch[1];
    const amount = amountMatch[1];
    
    console.log(`Paying ${amount} USDC to ${recipient}`);
    
    // 3. Execute payment
    const hash = await client.writeContract({
      address: USDC_ADDRESS,
      abi: ERC20_ABI,
      functionName: 'transfer',
      args: [recipient, parseUnits(amount, 6)]
    });
    
    console.log(`Payment sent: ${hash}`);
    
    // 4. Retry with proof
    res = await fetch(url, {
      headers: {
        'Authorization': `x402-proof ${hash}`
      }
    });
  }

  return res.json();
}

// Usage
const data = await fetchWith402(
  'https://402payment-test.com/api/x402',
  process.env.PRIVATE_KEY
);
console.log('Data:', data);

import requests
import re
from web3 import Web3
from eth_account import Account

# Base network RPC
w3 = Web3(Web3.HTTPProvider('https://mainnet.base.org'))

USDC_ADDRESS = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
ERC20_ABI = [{
    'name': 'transfer',
    'type': 'function',
    'stateMutability': 'nonpayable',
    'inputs': [
        {'name': 'to', 'type': 'address'},
        {'name': 'amount', 'type': 'uint256'}
    ],
    'outputs': [{'name': '', 'type': 'bool'}]
}]

def fetch_with_402(url, private_key):
    # Initialize account
    account = Account.from_key(private_key)
    
    # 1. Initial request
    res = requests.get(url)
    
    if res.status_code == 402:
        print('Payment Required')
        
        # 2. Parse payment details
        auth = res.headers['WWW-Authenticate']
        recipient = re.search(r'address="([^"]+)"', auth).group(1)
        amount = re.search(r'amount="([^"]+)"', auth).group(1)
        
        print(f'Paying {amount} USDC to {recipient}')
        
        # 3. Execute payment
        usdc = w3.eth.contract(
            address=USDC_ADDRESS,
            abi=ERC20_ABI
        )
        
        tx = usdc.functions.transfer(
            recipient,
            int(float(amount) * 10**6)  # USDC has 6 decimals
        ).build_transaction({
            'from': account.address,
            'nonce': w3.eth.get_transaction_count(account.address),
            'gas': 100000,
            'gasPrice': w3.eth.gas_price
        })
        
        signed = account.sign_transaction(tx)
        tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
        
        print(f'Payment sent: {tx_hash.hex()}')
        
        # 4. Retry with proof
        res = requests.get(url, headers={
            'Authorization': f'x402-proof {tx_hash.hex()}'
        })
    
    return res.json()

# Usage
import os
data = fetch_with_402(
    'https://402payment-test.com/api/x402',
    os.environ['PRIVATE_KEY']
)
print('Data:', data)