บันทึกการลอง x402 ครั้งแรก

app.use(
  paymentMiddleware(
    {
      "GET /weather": {
        accepts: [...],                 // As many networks / schemes as you want to support
        description: "Weather data",    // What your endpoint does
      },
    },
  )
);

package main

import (
  "encoding/json"
  "fmt"
  "net/http"
  "net/url"
  "os"
  "strings"
  "time"

  x402 "github.com/coinbase/x402/go"
  x402http "github.com/coinbase/x402/go/http"
  ginmw "github.com/coinbase/x402/go/http/gin"
  evm "github.com/coinbase/x402/go/mechanisms/evm/exact/server"
  ginfw "github.com/gin-gonic/gin"
  "github.com/joho/godotenv"
)

const (
  DefaultPort = "4900"
)

func main() {
  godotenv.Load()

  evmAddress := os.Getenv("EVM_PAYEE_ADDRESS")
  if evmAddress == "" {
    fmt.Println("❌ EVM_PAYEE_ADDRESS environment variable is required")
    os.Exit(1)
  }

  facilitatorURL := os.Getenv("FACILITATOR_URL")
  if facilitatorURL == "" {
    fmt.Println("❌ FACILITATOR_URL environment variable is required")
    fmt.Println("   Example: https://x402.org/facilitator")
    os.Exit(1)
  }

  port := os.Getenv("PORT")
  if port == "" {
    port = DefaultPort
  }

  // Network configuration - Base Sepolia testnet
  evmNetwork := x402.Network("eip155:84532")
  coinGeckoClient := &http.Client{Timeout: 5 * time.Second}

  fmt.Printf("🚀 Starting Gin x402 server...\n")
  fmt.Printf("   EVM Payee address: %s\n", evmAddress)
  fmt.Printf("   EVM Network: %s\n", evmNetwork)
  fmt.Printf("   Facilitator: %s\n", facilitatorURL)

  r := ginfw.Default()

  // Create HTTP facilitator client
  facilitatorClient := x402http.NewHTTPFacilitatorClient(&x402http.FacilitatorConfig{
    URL: facilitatorURL,
  })

  /**
   * Configure x402 payment middleware
   *
   * This middleware protects specific routes with payment requirements.
   * When a client accesses a protected route without payment, they receive
   * a 402 Payment Required response with payment details.
   */
  routes := x402http.RoutesConfig{
    "GET /crypto/price": {
      Accepts: x402http.PaymentOptions{
        {
          Scheme:  "exact",
          Price:   "$0.001",
          Network: evmNetwork,
          PayTo:   evmAddress,
        },
      },
      Description: "Get crypto price for a symbol",
      MimeType:    "application/json",
    },
  }

  // Apply x402 payment middleware
  r.Use(ginmw.X402Payment(ginmw.Config{
    Routes:      routes,
    Facilitator: facilitatorClient,
    Schemes: []ginmw.SchemeConfig{
      {Network: evmNetwork, Server: evm.NewExactEvmScheme()},
    },
    Timeout: 30 * time.Second,
  }))

  /**
   * Protected endpoint - requires $0.001 USDC payment
   *
   * Clients must provide a valid x402 payment to access this endpoint.
   * The payment is verified and settled before the endpoint handler runs.
   */
  r.GET("/crypto/price", func(c *ginfw.Context) {
    symbol := strings.ToLower(strings.TrimSpace(c.DefaultQuery("symbol", "bitcoin")))
    vsCurrency := strings.ToLower(strings.TrimSpace(c.DefaultQuery("vs_currency", "usd")))

    if symbol == "" || vsCurrency == "" {
      c.JSON(http.StatusBadRequest, ginfw.H{
        "error": "symbol and vs_currency are required",
      })
      return
    }

    upstreamURL := fmt.Sprintf(
      "https://api.coingecko.com/api/v3/simple/price?ids=%s&vs_currencies=%s",
      url.QueryEscape(symbol),
      url.QueryEscape(vsCurrency),
    )

    req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, upstreamURL, nil)
    if err != nil {
      c.JSON(http.StatusInternalServerError, ginfw.H{"error": "failed to build upstream request"})
      return
    }

    resp, err := coinGeckoClient.Do(req)
    if err != nil {
      c.JSON(http.StatusBadGateway, ginfw.H{
        "error":   "upstream request error",
        "details": err.Error(),
      })
      return
    }

    var upstream map[string]map[string]float64
    if err := json.NewDecoder(resp.Body).Decode(&upstream); err != nil {
      c.JSON(http.StatusInternalServerError, ginfw.H{"error": "failed to decode upstream response"})
      return
    }

    symbolData, found := upstream[symbol]
    if !found {
      c.JSON(http.StatusNotFound, ginfw.H{"error": "symbol not found"})
      return
    }

    price, found := symbolData[vsCurrency]
    if !found {
      c.JSON(http.StatusNotFound, ginfw.H{"error": "currency not found for symbol"})
      return
    }

    c.JSON(http.StatusOK, ginfw.H{
      "symbol":     symbol,
      "vsCurrency": vsCurrency,
      "price":      price,
      "source":     "CoinGecko",
      "timestamp":  time.Now().Format(time.RFC3339),
    })
  })

  /**
   * Health check endpoint - no payment required
   *
   * This endpoint is not protected by x402 middleware.
   */
  r.GET("/health", func(c *ginfw.Context) {
    c.JSON(http.StatusOK, ginfw.H{
      "status":  "ok",
      "version": "1.0.0",
    })
  })

  fmt.Printf("   Server listening on http://localhost:%s\n\n", port)

  if err := r.Run(":" + port); err != nil {
    fmt.Printf("Error starting server: %v\n", err)
    os.Exit(1)
  }
}

import { x402Client, wrapFetchWithPayment, x402HTTPClient } from '@x402/fetch'
import { registerExactEvmScheme } from '@x402/evm/exact/client'
import { privateKeyToAccount } from 'viem/accounts'

import 'dotenv/config'

const privateKey = process.env.PRIVATE_KEY as `0x${string}`

const baseURL = 'http://localhost:4900'
const endpointPath = '/crypto/price?symbol=bitcoin&vs=usd'

async function main(): Promise<void> {
  const url = new URL(endpointPath, baseURL).toString()
  const evmSigner = privateKeyToAccount(privateKey)

  const client = new x402Client()
  registerExactEvmScheme(client, { signer: evmSigner })

  const fetchWithPayment = wrapFetchWithPayment(fetch, client)

  console.log(`Making request to: ${url}\n`)
  const response = await fetchWithPayment(url, { method: 'GET' })
  const body = await response.json()
  console.log('Response body:', body)

  if (response.ok) {
    const paymentResponse = new x402HTTPClient(client).getPaymentSettleResponse((name) =>
      response.headers.get(name),
    )
    console.log('\nPayment response:', JSON.stringify(paymentResponse, null, 2))
  } else {
    console.log(`\nNo payment settled (response status: ${response.status})`)
  }
}

main().catch((error) => {
  console.error(error?.response?.data?.error ?? error)
  process.exit(1)
})