import axios from 'axios';
import { wrapAxiosWithPayment, privateKeyToAccount } from 'x402-stacks';

// Create account from private key
const account = privateKeyToAccount(process.env.PRIVATE_KEY!, 'testnet');

// Wrap axios with automatic payment handling
const api = wrapAxiosWithPayment(
  axios.create({ baseURL: 'https://api.example.com' }),
  account
);

// Use normally - 402 payments are handled automatically!
const response = await api.get('/api/premium-data');
console.log(response.data);

import express from 'express';
import { paymentMiddleware, STXtoMicroSTX } from 'x402-stacks';

const app = express();

app.get(
  '/api/premium-data',
  paymentMiddleware({
    amount: STXtoMicroSTX(0.1), // 0.1 STX
    address: 'SP1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM',
    network: 'mainnet',
    facilitatorUrl: 'https://x402-facilitator.example.com',
  }),
  (req, res) => {
    res.json({ data: 'This is premium content' });
  }
);

app.listen(3000);

import axios from 'axios';
import { wrapAxiosWithPayment, privateKeyToAccount } from 'x402-stacks';

const account = privateKeyToAccount('your-private-key', 'testnet');

const api = wrapAxiosWithPayment(
  axios.create({ baseURL: 'https://api.example.com' }),
  account
);

// All requests automatically handle 402 responses
const data = await api.get('/premium-endpoint');

import { privateKeyToAccount } from 'x402-stacks';

const account = privateKeyToAccount(
  'your-private-key-hex',
  'mainnet' | 'testnet'
);
// Returns: { address, privateKey, network }

import { createPaymentClient, privateKeyToAccount } from 'x402-stacks';

const account = privateKeyToAccount(process.env.PRIVATE_KEY!, 'testnet');
const api = createPaymentClient(account, { baseURL: 'https://api.example.com' });

const response = await api.get('/premium-data');

import { decodePaymentResponse } from 'x402-stacks';

const response = await api.get('/premium-data');
const paymentInfo = decodePaymentResponse(response.headers['payment-response']);

if (paymentInfo) {
  console.log('Transaction ID:', paymentInfo.transaction);
  console.log('Payer:', paymentInfo.payer);
  console.log('Network:', paymentInfo.network);
}

paymentMiddleware({
  amount: string | bigint,           // Amount in microSTX or sats
  address: string,                   // Your Stacks address
  network: 'mainnet' | 'testnet',
  facilitatorUrl?: string,           // Facilitator API URL
  resource?: string,                 // Custom resource identifier
  description?: string,              // Human-readable description
  mimeType?: string,                 // Response MIME type
  tokenType?: 'STX' | 'sBTC',        // Default: 'STX'
  tokenContract?: TokenContract,     // Required for sBTC
})

import { getPayment } from 'x402-stacks';

app.get('/api/data', paymentMiddleware(config), (req, res) => {
  const payment = getPayment(req);
  if (payment) {
    console.log('Paid by:', payment.payer);
    console.log('Transaction:', payment.transaction);
  }
  res.json({ data: 'Premium content' });
});

import { X402PaymentVerifier, createVerifier } from 'x402-stacks';

// Using the class
const verifier = new X402PaymentVerifier(
  'https://facilitator.example.com',
  'testnet'
);

// Or using the factory function
const verifier = createVerifier('https://facilitator.example.com', 'testnet');

// Settle a signed transaction (broadcasts via facilitator)
const result = await verifier.settle(signedTxHex, {
  recipient: 'ST1...',
  amount: '100000',
  asset: 'STX',
});

if (result.success) {
  console.log('Payment confirmed:', result.transaction);
}

import {
  STXtoMicroSTX,
  microSTXtoSTX,
  BTCtoSats,
  satsToBTC,
  generateKeypair,
  isValidStacksAddress,
  formatPaymentAmount,
  getExplorerURL,
  getDefaultSBTCContract,
  networkToCAIP2,
  caip2ToNetwork,
} from 'x402-stacks';

// Convert amounts
const microSTX = STXtoMicroSTX(1.5);        // 1500000n
const stx = microSTXtoSTX(1500000n);        // "1.500000"
const sats = BTCtoSats(0.001);              // 100000n

// Generate a wallet
const wallet = generateKeypair('testnet');
// { privateKey, publicKey, address }

// Validate an address
isValidStacksAddress('SP1...');  // true

// Format for display
formatPaymentAmount(100000n);                        // "0.100000 STX"
formatPaymentAmount(100000n, { tokenType: 'sBTC' }); // "0.001000 sBTC"

// Get explorer link
getExplorerURL(txId, 'mainnet');

// CAIP-2 network conversion
networkToCAIP2('mainnet');  // "stacks:1"
networkToCAIP2('testnet');  // "stacks:2147483648"
caip2ToNetwork('stacks:1'); // "mainnet"

// client.ts
import axios from 'axios';
import { wrapAxiosWithPayment, privateKeyToAccount, decodePaymentResponse } from 'x402-stacks';

const account = privateKeyToAccount(process.env.PRIVATE_KEY!, 'testnet');
const api = wrapAxiosWithPayment(axios.create({ baseURL: SERVER_URL }), account);

// Just make the request - payment is automatic!
const response = await api.get('/api/premium-data');
console.log('Data:', response.data);

// Check payment details
const paymentResponse = decodePaymentResponse(response.headers['payment-response']);
if (paymentResponse) {
  console.log('Paid with tx:', paymentResponse.transaction);
}

// server.ts
import express from 'express';
import { paymentMiddleware, getPayment, STXtoMicroSTX } from 'x402-stacks';

const app = express();

app.get('/api/premium-data',
  paymentMiddleware({
    amount: STXtoMicroSTX(0.1),
    address: process.env.SERVER_ADDRESS!,
    network: 'testnet',
    facilitatorUrl: 'https://x402-backend.example.com',
    description: 'Premium API data access',
  }),
  (req, res) => {
    const payment = getPayment(req);
    console.log('Payment received from:', payment?.payer);
    res.json({ data: 'Premium content', paidBy: payment?.payer });
  }
);

app.listen(3000);

// server.ts
import { paymentMiddleware, STXtoMicroSTX } from 'x402-stacks';

// Different prices for different tiers
const tierPrices = {
  basic: STXtoMicroSTX(0.01),
  standard: STXtoMicroSTX(0.05),
  premium: STXtoMicroSTX(0.10),
};

app.get('/api/market-data/:tier',
  (req, res, next) => {
    const tier = req.params.tier as keyof typeof tierPrices;
    const amount = tierPrices[tier] || tierPrices.basic;

    paymentMiddleware({
      amount,
      address: SERVER_ADDRESS,
      network: 'testnet',
      description: `${tier} market data access`,
    })(req, res, next);
  },
  (req, res) => {
    res.json({ marketData: getMarketData(req.params.tier) });
  }
);

import { paymentMiddleware, BTCtoSats, getDefaultSBTCContract } from 'x402-stacks';

app.get(
  '/api/bitcoin-data',
  paymentMiddleware({
    amount: BTCtoSats(0.00001), // 0.00001 BTC (1000 sats)
    address: 'ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM',
    network: 'testnet',
    tokenType: 'sBTC',
    tokenContract: getDefaultSBTCContract('testnet'),
  }),
  (req, res) => {
    res.json({ data: 'Premium Bitcoin data' });
  }
);

import axios from 'axios';
import { wrapAxiosWithPayment, privateKeyToAccount } from 'x402-stacks';

const account = privateKeyToAccount(process.env.PRIVATE_KEY!, 'testnet');
const api = wrapAxiosWithPayment(axios.create(), account);

// Client automatically detects sBTC requirement and pays in sBTC
const data = await api.get('http://localhost:3003/api/bitcoin-data');

paymentMiddleware({
  // ...
  facilitatorUrl: 'https://your-facilitator.example.com',
})

// Old (V1)
import {
  withPaymentInterceptor,
  x402PaymentRequired,
  X402PaymentVerifier,
  decodeXPaymentResponse,
} from 'x402-stacks';

// New (V2 - default exports)
import {
  wrapAxiosWithPayment,      // was withPaymentInterceptor
  paymentMiddleware,          // was x402PaymentRequired
  X402PaymentVerifier,        // same name
  decodePaymentResponse,      // was decodeXPaymentResponse
} from 'x402-stacks';

// V1 functions still available with V1 suffix
import {
  wrapAxiosWithPaymentV1,
  paymentMiddlewareV1,
  X402PaymentVerifierV1,
} from 'x402-stacks';