import { wrapFetch } from '@dexterai/x402/client';

// Solana
const x402Fetch = wrapFetch(fetch, {
  walletPrivateKey: process.env.SOLANA_PRIVATE_KEY,
});

// EVM (Base, Polygon, Arbitrum, Optimism, Avalanche, SKALE)
const x402Fetch = wrapFetch(fetch, {
  evmPrivateKey: process.env.EVM_PRIVATE_KEY,  // requires: npm install viem
});

// Both — SDK picks the chain with balance
const x402Fetch = wrapFetch(fetch, {
  walletPrivateKey: process.env.SOLANA_PRIVATE_KEY,
  evmPrivateKey: process.env.EVM_PRIVATE_KEY,
});

// That's it. 402 responses are handled automatically.
const response = await x402Fetch('https://api.example.com/protected');

import { wrapFetch, getPaymentReceipt } from '@dexterai/x402/client';

const x402Fetch = wrapFetch(fetch, { walletPrivateKey: process.env.SOLANA_PRIVATE_KEY });
const response = await x402Fetch('https://api.example.com/protected');

const receipt = getPaymentReceipt(response);
if (receipt) {
  console.log('Paid:', receipt.transaction, 'on', receipt.network);
}

import { createX402Client } from '@dexterai/x402/client';

const client = createX402Client({
  wallets: {
    solana: solanaWallet,
    evm: evmWallet,
  },
});

// That's it. 402 responses are handled automatically.
const response = await client.fetch('https://api.example.com/protected');

const client = createX402Client({
  wallets: { solana: solanaWallet },
  rpcUrls: {
    'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': 'https://your-rpc.com',
  },
});

// Same address across EVM chains
app.get('/api/data', x402Middleware({
  payTo: '0xYourAddress',
  amount: '0.01',
  network: ['eip155:8453', 'eip155:137', 'eip155:42161', 'eip155:10'],
}));

// Different addresses per chain family
app.get('/api/data', x402Middleware({
  payTo: {
    'solana:*': 'YourSolanaAddress...',
    'eip155:*': '0xYourEvmAddress...',
  },
  amount: '0.01',
  network: ['solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', 'eip155:8453', 'eip155:137'],
}));

// Client - browser
import { createX402Client } from '@dexterai/x402/client';

// Client - Node.js (private key wallet)
import { wrapFetch, createKeypairWallet } from '@dexterai/x402/client';

// React hook
import { useX402Payment } from '@dexterai/x402/react';

// Server - Express middleware
import { x402Middleware } from '@dexterai/x402/server';

// Server - Access Pass (pay once, unlimited requests)
import { x402AccessPass } from '@dexterai/x402/server';

// Server - manual control
import { createX402Server } from '@dexterai/x402/server';

// Server - dynamic pricing
import { createDynamicPricing, createTokenPricing } from '@dexterai/x402/server';

// React - Access Pass hook
import { useAccessPass } from '@dexterai/x402/react';

// Chain adapters (advanced)
import { createSolanaAdapter, createEvmAdapter } from '@dexterai/x402/adapters';

// Utilities
import { toAtomicUnits, fromAtomicUnits } from '@dexterai/x402/utils';

import { toAtomicUnits, fromAtomicUnits } from '@dexterai/x402/utils';

// Convert dollars to atomic units (for API calls)
toAtomicUnits(0.05, 6);  // '50000'
toAtomicUnits(1.50, 6);  // '1500000'

// Convert atomic units back to dollars (for display)
fromAtomicUnits('50000', 6);   // 0.05
fromAtomicUnits(1500000n, 6);  // 1.5

import express from 'express';
import { x402Middleware } from '@dexterai/x402/server';

const app = express();

app.get('/api/protected',
  x402Middleware({
    payTo: 'YourSolanaAddress...',
    amount: '0.01',  // $0.01 USD
  }),
  (req, res) => {
    // This only runs after successful payment
    res.json({ data: 'protected content' });
  }
);

import express from 'express';
import { x402AccessPass } from '@dexterai/x402/server';

const app = express();

// Protect all /api routes with access pass
app.use('/api', x402AccessPass({
  payTo: 'YourSolanaAddress...',
  tiers: {
    '1h':  '0.50',   // $0.50 for 1 hour
    '24h': '2.00',   // $2.00 for 24 hours
  },
  ratePerHour: '0.50',  // also accept custom durations
}));

app.get('/api/data', (req, res) => {
  // Only runs with a valid access pass
  res.json({ data: 'premium content' });
});

import { wrapFetch } from '@dexterai/x402/client';

const x402Fetch = wrapFetch(fetch, {
  walletPrivateKey: process.env.SOLANA_PRIVATE_KEY,
  accessPass: { preferTier: '1h', maxSpend: '1.00' },
});

// First call: auto-purchases a 1-hour pass ($0.50 USDC)
const res1 = await x402Fetch('https://api.example.com/api/data');

// All subsequent calls for the next hour: uses cached JWT, zero payment
const res2 = await x402Fetch('https://api.example.com/api/data');
const res3 = await x402Fetch('https://api.example.com/api/data');

import { createX402Server } from '@dexterai/x402/server';

const server = createX402Server({
  payTo: 'YourAddress...',
  network: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
});

// In your route handler
app.post('/protected', async (req, res) => {
  const paymentSig = req.headers['payment-signature'];

  if (!paymentSig) {
    const requirements = await server.buildRequirements({
      amountAtomic: '50000',  // $0.05 USDC
      resourceUrl: req.originalUrl,
    });
    res.setHeader('PAYMENT-REQUIRED', server.encodeRequirements(requirements));
    return res.status(402).json({});
  }

  const result = await server.settlePayment(paymentSig);
  if (!result.success) {
    return res.status(402).json({ error: result.errorReason });
  }

  res.json({ data: 'Your protected content' });
});

import { createX402Server, createDynamicPricing } from '@dexterai/x402/server';

const server = createX402Server({ payTo: '...', network: '...' });
const pricing = createDynamicPricing({
  unitSize: 1000,      // chars per unit
  ratePerUnit: 0.01,   // $0.01 per unit
  minUsd: 0.01,        // floor
  maxUsd: 10.00,       // ceiling
});

app.post('/api/llm', async (req, res) => {
  const { prompt } = req.body;
  const paymentSig = req.headers['payment-signature'];

  if (!paymentSig) {
    const quote = pricing.calculate(prompt);
    const requirements = await server.buildRequirements({
      amountAtomic: quote.amountAtomic,
      resourceUrl: req.originalUrl,
    });
    res.setHeader('PAYMENT-REQUIRED', server.encodeRequirements(requirements));
    res.setHeader('X-Quote-Hash', quote.quoteHash);
    return res.status(402).json({ usdAmount: quote.usdAmount });
  }

  // Validate quote hasn't changed (prevents prompt manipulation)
  const quoteHash = req.headers['x-quote-hash'];
  if (!pricing.validateQuote(prompt, quoteHash)) {
    return res.status(400).json({ error: 'Prompt changed, re-quote required' });
  }

  const result = await server.settlePayment(paymentSig);
  if (!result.success) return res.status(402).json({ error: result.errorReason });

  const response = await runLLM(prompt);
  res.json(response);
});

import { createX402Server, createTokenPricing, MODEL_PRICING } from '@dexterai/x402/server';

const server = createX402Server({ payTo: '...', network: '...' });
const pricing = createTokenPricing({
  model: 'gpt-4o-mini',  // Uses real OpenAI rates
  // minUsd: 0.001,      // Optional floor
  // maxUsd: 50.0,       // Optional ceiling
});

app.post('/api/chat', async (req, res) => {
  const { prompt, systemPrompt } = req.body;
  const paymentSig = req.headers['payment-signature'];

  if (!paymentSig) {
    const quote = pricing.calculate(prompt, systemPrompt);
    const requirements = await server.buildRequirements({
      amountAtomic: quote.amountAtomic,
      resourceUrl: req.originalUrl,
      description: `${quote.model}: ${quote.inputTokens.toLocaleString()} tokens`,
    });
    res.setHeader('PAYMENT-REQUIRED', server.encodeRequirements(requirements));
    res.setHeader('X-Quote-Hash', quote.quoteHash);
    return res.status(402).json({
      inputTokens: quote.inputTokens,
      usdAmount: quote.usdAmount,
      model: quote.model,
      tier: quote.tier,
    });
  }

  // Validate quote hasn't changed
  const quoteHash = req.headers['x-quote-hash'];
  if (!pricing.validateQuote(prompt, quoteHash)) {
    return res.status(400).json({ error: 'Prompt changed, re-quote required' });
  }

  const result = await server.settlePayment(paymentSig);
  if (!result.success) return res.status(402).json({ error: result.errorReason });

  const response = await openai.chat.completions.create({
    model: pricing.config.model,
    messages: [{ role: 'user', content: prompt }],
    max_completion_tokens: pricing.modelInfo.maxTokens,
  });

  res.json({ 
    response: response.choices[0].message.content,
    transaction: result.transaction,
  });
});

import { MODEL_PRICING, getAvailableModels } from '@dexterai/x402/server';

// Get all models sorted by tier and price
const models = getAvailableModels();
// → [{ model: 'gpt-5-nano', inputRate: 0.05, tier: 'fast' }, ...]

// Check pricing for a specific model
MODEL_PRICING['gpt-4o-mini'];
// → { input: 0.15, output: 0.6, maxTokens: 4096, tier: 'fast' }

// Anthropic Claude
const pricing = createTokenPricing({
  model: 'claude-3-sonnet',
  inputRate: 3.0,    // $3.00 per 1M input tokens
  outputRate: 15.0,  // $15.00 per 1M output tokens
  maxTokens: 4096,
});

// Google Gemini
const pricing = createTokenPricing({
  model: 'gemini-1.5-pro',
  inputRate: 1.25,
  outputRate: 5.0,
});

// Custom/local model with custom tokenizer
const pricing = createTokenPricing({
  model: 'llama-3-70b',
  inputRate: 0.50,
  tokenizer: (text) => llamaTokenizer.encode(text).length,
});

import { x402Middleware } from '@dexterai/x402/server';

// Default injection: adds _x402_sponsored field to JSON response
app.get('/api/data',
  x402Middleware({
    payTo: '...', amount: '0.01',
    sponsoredAccess: true,
  }),
  (req, res) => res.json({ data: 'content' })
);
// Agent receives: { _x402_sponsored: [{ resourceUrl, description, sponsor }], data: 'content' }

// Custom injection: control where recommendations appear
app.get('/api/data',
  x402Middleware({
    payTo: '...', amount: '0.01',
    sponsoredAccess: {
      inject: (body, recs) => ({ ...body, related_tools: recs }),
      onMatch: (recs, settlement) => {
        console.log(`Matched ${recs.length} recommendations for tx ${settlement.transaction}`);
      },
    },
  }),
  (req, res) => res.json({ data: 'content' })
);

import {
  wrapFetch,
  getSponsoredRecommendations,
  fireImpressionBeacon,
} from '@dexterai/x402/client';

const x402Fetch = wrapFetch(fetch, { walletPrivateKey: key });
const response = await x402Fetch('https://api.example.com/data');

// Extract typed recommendations from the payment receipt
const recs = getSponsoredRecommendations(response);
if (recs) {
  for (const rec of recs) {
    console.log(`${rec.sponsor}: ${rec.description} -- ${rec.resourceUrl}`);
  }
  // Confirm delivery to the ad network
  await fireImpressionBeacon(response);
}

import type { SponsoredRecommendation, SponsoredAccessSettlementInfo } from '@dexterai/x402/client';

interface SponsoredRecommendation {
  resourceUrl: string;    // The URL to call
  description: string;    // Agent-readable description
  sponsor: string;        // Brand name
  bazaarId?: string;      // Bazaar catalog ID
  price?: string;         // Cost in atomic units
  currency?: string;      // e.g., "USDC"
}

// All campaign management is x402-gated at x402ads.io
const x402Fetch = wrapFetch(fetch, { walletPrivateKey: key });

// Create a campaign ($0.10 USDC)
const res = await x402Fetch('https://x402ads.io/v1/agent/campaigns', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    name: 'Promote My API',
    rec_resource_url: 'https://api.example.com/data',
    rec_description: 'Real-time market data',
    rec_sponsor_name: 'Example Corp',
    target_categories: ['defi', 'data'],
    bid_strategy: 'cpa',
    max_bid_amount: '50000',
    budget_daily: '5000000',
  }),
});