Bazaar (Discovery Layer)

package main

import (
    "context"
    "fmt"

    "github.com/coinbase/x402/go/extensions/bazaar"
    x402http "github.com/coinbase/x402/go/http"
)

func main() {
    ctx := context.Background()

    // Create facilitator client and extend with bazaar
    facilitatorClient := x402http.NewHTTPFacilitatorClient(&x402http.FacilitatorConfig{
        URL: "https://x402.org/facilitator",
    })
    client := bazaar.WithBazaar(facilitatorClient)

    // List discovery resources
    response, err := client.ListDiscoveryResources(ctx, &bazaar.ListDiscoveryResourcesParams{
        Type:   "http",
        Limit:  20,
        Offset: 0,
    })
    if err != nil {
        panic(err)
    }

    // Filter services under $0.10
    usdcAsset := "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
    maxPrice := 100000 // $0.10 in USDC atomic units (6 decimals)

    for _, item := range response.Items {
        for _, paymentReq := range item.Accepts {
            // Parse asset and maxAmountRequired from payment requirements
            if asset, ok := paymentReq["asset"].(string); ok && asset == usdcAsset {
                if maxAmount, ok := paymentReq["maxAmountRequired"].(string); ok {
                    // Convert and compare price
                    fmt.Printf("Found service: %s\n", item.Resource)
                }
            }
        }
    }
}

from x402.http import FacilitatorConfig, HTTPFacilitatorClient

facilitator = HTTPFacilitatorClient(
    FacilitatorConfig(url="https://x402.org/facilitator")
)

response = await facilitator.list_resources(type="http")

# Filter services under $0.10
usdc_asset = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
max_price = 100000  # $0.10 in USDC atomic units (6 decimals)

affordable_services = [
    item
    for item in response.items
    if any(
        payment_req.asset == usdc_asset
        and int(payment_req.max_amount_required) < max_price
        for payment_req in item.accepts
    )
]

import asyncio

from eth_account import Account

from x402 import x402Client
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client


async def main() -> None:
    account = Account.from_key("0xYourPrivateKey")
    client = x402Client()
    register_exact_evm_client(client, EthAccountSigner(account))

    # Select a service from discovery (from Step 1)
    selected_service = affordable_services[0]

    # Select the payment method of your choice
    selected_payment_requirements = selected_service.accepts[0]
    input_schema = selected_payment_requirements.output_schema.input

    # Make the request using httpx client
    async with x402HttpxClient(client) as http:
        response = await http.request(
            method=input_schema.method,
            url=input_schema.resource,
            params={"location": "San Francisco"}  # Based on input_schema
        )
        await response.aread()
        print(f"Response data: {response.json()}")


asyncio.run(main())

from fastapi import FastAPI

from x402.http import FacilitatorConfig, HTTPFacilitatorClient, PaymentOption
from x402.http.middleware.fastapi import PaymentMiddlewareASGI
from x402.http.types import RouteConfig
from x402.mechanisms.evm.exact import ExactEvmServerScheme
from x402.server import x402ResourceServer

app = FastAPI()

# Create facilitator client (CDP mainnet)
facilitator = HTTPFacilitatorClient(
    FacilitatorConfig(url="https://x402.org/facilitator")
)

# Create resource server and register EVM scheme
server = x402ResourceServer(facilitator)
server.register("eip155:8453", ExactEvmServerScheme())

# Define routes with Bazaar discovery metadata
routes: dict[str, RouteConfig] = {
    "GET /weather": RouteConfig(
        accepts=[
            PaymentOption(
                scheme="exact",
                pay_to="0xYourAddress",
                price="$0.001",
                network="eip155:8453",
            ),
        ],
        mime_type="application/json",
        description="Get current weather data for any location",
        extensions={
            "bazaar": {
                "discoverable": True,
                "inputSchema": {
                    "queryParams": {
                        "location": {
                            "type": "string",
                            "description": "City name or coordinates",
                            "required": True,
                        }
                    }
                },
                "outputSchema": {
                    "type": "object",
                    "properties": {
                        "temperature": {"type": "number"},
                        "conditions": {"type": "string"},
                        "humidity": {"type": "number"},
                    },
                },
            }
        },
    ),
}

app.add_middleware(PaymentMiddlewareASGI, routes=routes, server=server)

package main

import (
    x402 "github.com/coinbase/x402/go"
    "github.com/coinbase/x402/go/extensions/bazaar"
    "github.com/coinbase/x402/go/extensions/types"
    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"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    facilitatorClient := x402http.NewHTTPFacilitatorClient(&x402http.FacilitatorConfig{
        URL: "https://x402.org/facilitator",
    })

    // Create Bazaar Discovery Extension with input/output schemas
    discoveryExtension, _ := bazaar.DeclareDiscoveryExtension(
        bazaar.MethodGET,
        map[string]interface{}{"location": "San Francisco"},
        types.JSONSchema{
            "properties": map[string]interface{}{
                "location": map[string]interface{}{
                    "type":        "string",
                    "description": "City name or coordinates",
                },
            },
            "required": []string{"location"},
        },
        "",
        &types.OutputConfig{
            Schema: types.JSONSchema{
                "properties": map[string]interface{}{
                    "temperature": map[string]interface{}{"type": "number"},
                    "conditions":  map[string]interface{}{"type": "string"},
                    "humidity":    map[string]interface{}{"type": "number"},
                },
            },
        },
    )

    routes := x402http.RoutesConfig{
        "GET /weather": {
            Accepts: x402http.PaymentOptions{{
                Scheme:  "exact",
                PayTo:   "0xYourAddress",
                Price:   "$0.001",
                Network: x402.Network("eip155:8453"),
            }},
            Description: "Get current weather data for any location",
            Extensions: map[string]interface{}{
                types.BAZAAR: discoveryExtension,
            },
        },
    }

    r.Use(ginmw.X402Payment(ginmw.Config{
        Routes:      routes,
        Facilitator: facilitatorClient,
        Schemes: []ginmw.SchemeConfig{{
            Network: x402.Network("eip155:8453"),
            Server:  evm.NewExactEvmScheme(),
        }},
    }))

    r.GET("/weather", func(c *gin.Context) {
        location := c.DefaultQuery("location", "San Francisco")
        c.JSON(200, gin.H{
            "location":    location,
            "temperature": 70,
            "conditions":  "sunny",
            "humidity":    45,
        })
    })

    r.Run(":4021")
}