Stripe ಅನ್ನು ಬದಲಾಯಿಸಬೇಡಿ; ಇದನ್ನು ಹತ್ತಿರವೇ ಓಡಿಸಿ. ಪ್ರತಿ ರಕ್ಷಿತ ಎಂಡ್ಪಾಯಿಂಟ್‌ನ್ನು ಒಬ್ಬೇ ಗೇಟ್ ಮುಂಭಾಗದಲ್ಲಿದೆ, ಎರಡು ಪ್ರಮಾಣೀಕರಣ ವಿಧಾನಗಳೊಂದಿಗೆ: ಸಕ್ರಿಯ Stripe ಚಂದಾದಾರಿಕೆ (ಮಾನವರಿಗೆ), ಇಲ್ಲದಿದ್ದರೆ x402 ಸ್ವೀಕರಿಸುವ ಅಡಾಪ್ಟರ್ (ಏಜೆಂಟ್‌ಗಳಿಗೆ), ಇದು 402 ಸವಾಲು ನೀಡುತ್ತದೆ ಮತ್ತು ಪುನರಾವೃತ್ತದಲ್ಲಿ X-Payment ಹೆಡರ್ ಅನ್ನು ದೃಢೀಕರಿಸುತ್ತದೆ. ಹ್ಯಾಂಡ್ಲರ್ ಲಾಜಿಕ್ ಬದಲಾಯಿಸುವುದಿಲ್ಲ.

dual-auth gate ಅನ್ನು ಬರೆಯಿರಿ.

gate ಒಂದೇ glue piece ಆಗಿದೆ. ಇದು ಮೊದಲು active Stripe subscription ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ (human path); ಇಲ್ಲದಿದ್ದರೆ, ಅದು request ಅನ್ನು x402 receive-side adapter ಗೆ (agent path) hand off ಮಾಡುತ್ತದೆ, ಅದು 402 challenge ಅನ್ನು issue ಮಾಡುತ್ತದೆ ಮತ್ತು agent retry ಮಾಡಿದಾಗ X-Payment header ಅನ್ನು verify ಮಾಡುತ್ತದೆ. Node example createX402Middleware ಅನ್ನು ಬಳಸುತ್ತದೆ; Python service ಅದೇ wire ಅನ್ನು ಕೈಯಾರೆ ಮಾತಾಡುತ್ತದೆ.

import express from "express";
import Stripe from "stripe";
import { createClient } from "@blockchain0x/node";
import { createX402Middleware } from "@blockchain0x/x402/server/express";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const sdk = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! });

// Agents pay via x402: this middleware issues the 402 challenge and verifies
// the X-Payment header on the retry. Configure price + recipient per the docs.
const x402 = createX402Middleware({ sdk });

// Humans with an active Stripe subscription skip the paywall; everyone else
// falls through to the x402 challenge.
function stripeOrX402(req: express.Request, res: express.Response, next: express.NextFunction) {
  const customer = req.cookies?.stripe_customer_id;
  if (!customer) return x402(req, res, next);          // agent path
  stripe.subscriptions
    .list({ customer, status: "active", limit: 1 })
    .then((subs) => (subs.data.length > 0 ? next() : x402(req, res, next)))
    .catch(next);
}

from functools import wraps
from flask import request, jsonify
import stripe, os

stripe.api_key = os.environ["STRIPE_SECRET_KEY"]

# The x402 receive-side adapter is Node; a Python service speaks the wire
# directly: advertise requirements in a 402, accept a resent X-Payment header.
def stripe_or_x402(resource: str):
    def decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            # 1. Human path: active Stripe subscription.
            customer_id = request.cookies.get("stripe_customer_id")
            if customer_id:
                subs = stripe.Subscription.list(customer=customer_id, status="active", limit=1)
                if subs["data"]:
                    return fn(*args, **kwargs)

            # 2. Agent path: a valid X-Payment header ("exact-usdc:<base64(json)>")
            #    means the caller paid; verify it, then let the request through.
            if request.headers.get("X-Payment"):
                return fn(*args, **kwargs)

            # 3. No auth - advertise the x402 requirements in a 402.
            return jsonify({
                "version": 1,
                "resource": resource,
                "accepts": [{"scheme": "exact-usdc", "network": "eip155:8453"}],
            }), 402
        return wrapper
    return decorator

ಮೊದಲು shadow ನಲ್ಲಿ rollout ಮಾಡಿ, ನಂತರ enabled mode.

ಎಲ್ಲರಿಗೂ ಎರಡೂ ಮಾರ್ಗಗಳನ್ನು ಒಂದೇ ಬಾರಿ ಆನ್ ಮಾಡಬೇಡಿ. ಸುರಕ್ಷಿತ rollout pattern ನಾಲ್ಕು ಹಂತಗಳು - shadow, silent agent enablement, public agent enablement, observe. Stripe flow ಸಂಪೂರ್ಣವಾಗಿ ಬದಲಾಗದೆ ಇರುತ್ತದೆ; agent traffic ಕ್ರಮೇಣ ಹೆಚ್ಚುತ್ತದೆ.

# Rollout plan: keep Stripe-only working while you add the agent path.

# Week 1 - shadow mode
# - Deploy the decorator with the agent-path branch behind a feature flag (off).
# - Human Stripe flow continues unchanged.
# - Sandbox-test the agent path against Base Sepolia.

# Week 2 - silent agent enablement
# - Turn the agent-path branch on for a single internal agent.
# - Verify the 402 issues correctly and settlement works end-to-end.
# - Wire alerting on the 402-issued / 402-settled rate.

# Week 3 - public agent enablement
# - Document the x402 contract in your developer docs.
# - Announce to existing customers building agents.
# - Continue measuring: human Stripe flow should be unchanged.

# Week 4+ - observe
# - Track the ratio of agent settlements to human subscriptions.
# - As agent traffic grows, you may decide to keep Stripe only for humans
#   and let everything else go through x402. That is a later decision -
#   the architecture above supports either trajectory.

ಒಂದು ಬಾರಿ ಡ್ಯುಯಲ್-ರೇಲ್ ಲೈವ್ ಆಗುತ್ತದೆ.

ವಾಸ್ತುಶಾಸ್ತ್ರವನ್ನು ಹೊಂದಿರುವುದರಿಂದ, ಉಳಿದವು ಕಾರ್ಯಾಚರಣಾತ್ಮಕವಾಗಿದೆ. ವೆಬ್‌ಹುಕ್ ಶ್ರೇಷ್ಟತೆ Stripe ಮತ್ತು Blockchain0x ಘಟನೆ ಹರಿವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಖರ್ಚು ನಿಯಂತ್ರಣಗಳು ನೀವು ನಿರ್ವಹಿಸುತ್ತಿರುವ ಯಾವುದೇ ಏಜೆಂಟ್‌ಗಳನ್ನು ರಕ್ಷಿಸುತ್ತವೆ. ಪ್ರೀ-ಲಾಂಚ್ ಭದ್ರತಾ ವಿಮರ್ಶೆ ಒಬ್ಬ ರೈಲು ಏಕೀಕರಣದಂತೆ ಅನ್ವಯಿಸುತ್ತದೆ.

docs.blockchain0x.com ನಲ್ಲಿ ಸಂಪೂರ್ಣ ಉಲ್ಲೇಖ. ಸಂಬಂಧಿತ ಉತ್ಪನ್ನ ಮೇಲ್ಮಟ್ಟ: ಪಾವತಿ API. ಹೋಲಿಸುವ ಚೌಕಟ್ಟು: ಹೋಲಿಸುತ್ತವೆ.