Built for Developers

// Express middleware
import { verifyShadowPayToken } from '@shadowpay/sdk';

app.use('/api/premium/*', async (req, res, next) => {
  const token = req.headers.authorization?.replace('Bearer ', '');
  
  if (!token) {
    return res.status(402).json({
      x402Version: 1,
      accepts: [{
        scheme: 'zkproof',
        network: 'solana-mainnet',
        maxAmountRequired: '1000000',
        resource: req.path,
        payTo: process.env.MERCHANT_WALLET
      }]
    });
  }
  
  try {
    const payment = await verifyShadowPayToken(token, {
      apiKey: process.env.SHADOWPAY_API_KEY
    });
    
    if (payment.valid) {
      req.payment = payment;
      next();
    } else {
      res.status(402).json({ error: 'Invalid payment' });
    }
  } catch (error) {
    res.status(500).json({ error: 'Verification failed' });
  }
});

from shadowpay import ShadowPayClient

# Initialize client
client = ShadowPayClient(
    base_url='https://shadow.radr.fun',
    network='mainnet'
)

# Verify payment (merchant side)
@app.route('/api/premium-data')
def premium_data():
    token = request.headers.get('Authorization', '').replace('Bearer ', '')
    
    if not token:
        return jsonify({
            'x402Version': 1,
            'accepts': [{
                'scheme': 'zkproof',
                'network': 'solana-mainnet',
                'maxAmountRequired': '1000000',
                'resource': '/api/premium-data',
                'payTo': os.environ['MERCHANT_WALLET']
            }]
        }), 402
    
    payment = client.verify_token(
        token=token,
        api_key=os.environ['SHADOWPAY_API_KEY']
    )
    
    if payment['valid']:
        return jsonify({'data': 'Premium content here!'})
    else:
        return jsonify({'error': 'Invalid payment'}), 402

use shadowpay::{ShadowPayClient, PaymentRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize client
    let client = ShadowPayClient::new(
        "https://shadow.radr.fun",
        Network::Mainnet
    ).await?;
    
    // Create payment request
    let payment = PaymentRequest::new()
        .user_wallet("USER_WALLET_ADDRESS")
        .merchant_wallet("MERCHANT_WALLET_ADDRESS")
        .amount(1_000_000) // 0.001 SOL
        .build()?;
    
    // Authorize and pay
    let result = client.pay(payment).await?;
    
    println!("✅ Payment authorized: {}", result.access_token);
    println!("⏳ Settlement in progress...");
    
    // Wait for settlement (optional)
    let settlement = result.wait_for_settlement().await?;
    println!("✅ Settled: {}", settlement.tx_hash);
    
    Ok(())
}

// Configure webhook
await client.merchant.setWebhook({
  url: 'https://your-app.com/webhooks/shadowpay',
  events: ['payment.settled', 'payment.failed'],
  secret: 'your-webhook-secret'
});

// Handle webhook in your app
app.post('/webhooks/shadowpay', (req, res) => {
  // Verify signature
  const signature = req.headers['x-shadowpay-signature'];
  const isValid = client.verifyWebhookSignature(
    req.body,
    signature,
    'your-webhook-secret'
  );
  
  if (!isValid) {
    return res.status(401).send('Invalid signature');
  }
  
  const { event, data } = req.body;
  
  switch (event) {
    case 'payment.settled':
      console.log(`✅ Payment settled: ${data.amount} lamports`);
      console.log(`TX: ${data.txHash}`);
      // Update database, grant access, etc.
      break;
      
    case 'payment.failed':
      console.log(`❌ Payment failed: ${data.reason}`);
      // Handle failure, notify user, etc.
      break;
  }
  
  res.sendStatus(200);
});

try {
  const payment = await client.pay({
    userWallet: 'USER_WALLET',
    merchantWallet: 'MERCHANT_WALLET',
    amount: 1_000_000
  });
} catch (error) {
  if (error.code === 'INSUFFICIENT_ESCROW') {
    console.error('❌ User needs to deposit more SOL to escrow');
    // Prompt user to fund escrow
  } else if (error.code === 'PROOF_GENERATION_FAILED') {
    console.error('❌ ZK proof generation failed, retrying...');
    // Retry payment
  } else if (error.code === 'MERCHANT_NOT_FOUND') {
    console.error('❌ Invalid merchant wallet or API key');
    // Check configuration
  } else {
    console.error('❌ Payment failed:', error.message);
    // Generic error handling
  }
}