agentscore-commerce 1.3.2__tar.gz → 1.3.4__tar.gz

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/CLAUDE.md

@@ -9,7 +9,7 @@ Every helper is extracted from a real consumer, not speculated.
 | Submodule | What it is |
 |---|---|
 | `agentscore_commerce.identity.{fastapi,flask,django,aiohttp,sanic,middleware}` | Trust gate middleware (KYC, age, sanctions, jurisdiction) |
-| `agentscore_commerce.payment` | Networks/USDC/rails registries, paymentauth.org directive builders, `create_x402_server` (wraps official `x402[evm]>=2.9` peer dep with v1+v2 dual-register + bazaar extension; for `facilitator="coinbase"` mints per-endpoint CDP JWTs via `cdp-sdk` (install with `coinbase` extra) and points HTTPFacilitatorClient at `api.cdp.coinbase.com/platform/v2/x402` — bare `x402Facilitator()` is empty and the CDP docs' env-var-only snippet does NOT auto-auth), `process_x402_settle` (single-call verify+settle wrapper around `x402ResourceServer`'s real 2.9 API: `build_payment_requirements` → `verify_payment` → `settle_payment`; auto-coerces dict `resource_config` with camelCase keys → typed `ResourceConfig`), `create_mppx_server` (wraps `pympp[server,tempo,stripe]>=0.6` peer dep with Tempo charge/session + Stripe SPT helpers), dispatch-by-network, signer extraction, WWW-Authenticate header, Settlement-Overrides header |
+| `agentscore_commerce.payment` | Networks/USDC/rails registries, paymentauth.org directive builders, `create_x402_server` (wraps `x402[evm]>=2.9` + `cdp-sdk` for `facilitator="coinbase"`; install via the `coinbase` extra), `build_x402_accepts_for_402` (build the 402's `accepts[]` from the registered scheme — derives the right `extra.name` per network), `process_x402_settle` (verify+settle in one call), `create_mppx_server` (wraps `pympp[server,tempo,stripe]>=0.6`), dispatch-by-network, signer extraction, WWW-Authenticate header, Settlement-Overrides header |
 | `agentscore_commerce.discovery` | Discovery probe, Bazaar wrapper, `/.well-known/mpp.json`, `llms.txt` builder, `skill.md` builder (Claude-Skill-compatible agent-discovery manifest), OpenAPI snippets, `NoindexNonDiscoveryMiddleware` ASGI middleware |
 | `agentscore_commerce.challenge` | 402-body builders: accepted_methods, identity_metadata, how_to_pay, agent_instructions, build_402_body, `build_validation_error` (4xx body builder) |
 | `agentscore_commerce.stripe_multichain` | Multichain PaymentIntent helper, deposit-address lookup, testnet simulator, mppx Stripe wrapper |

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentscore-commerce
-Version: 1.3.2
+Version: 1.3.4
 Summary: Agent commerce SDK for Python — identity middleware (FastAPI, Flask, Django, AIOHTTP, Sanic, ASGI) + payment helpers + 402 builders + discovery + Stripe multichain. The full merchant-side toolkit for AgentScore-powered agent commerce.
 Project-URL: Homepage, https://agentscore.sh
 Project-URL: Repository, https://github.com/agentscore/python-commerce
@@ -291,6 +291,22 @@ await simulate_deposit_if_test_mode(SimulateDepositIfTestModeInput(
 ))
 ```
 
+## Build the x402 accepts entry for the 402 challenge
+
+```python
+from agentscore_commerce.payment import build_x402_accepts_for_402
+
+x402_accepts = build_x402_accepts_for_402(
+    x402_server,
+    network=X402_BASE,
+    price=f"${total_usd}",
+    pay_to=os.environ["TREASURY_BASE_RECIPIENT"],
+    max_timeout_seconds=300,
+)
+```
+
+Returns a list of plain dicts ready for the 402 body's `accepts[]`. `extra.name` is derived from the registered scheme metadata so the EIP-712 domain matches the on-chain USDC contract.
+
 ## Drop-in 402 + settle (x402)
 
 ```python

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/README.md

@@ -247,6 +247,22 @@ await simulate_deposit_if_test_mode(SimulateDepositIfTestModeInput(
 ))
 ```
 
+## Build the x402 accepts entry for the 402 challenge
+
+```python
+from agentscore_commerce.payment import build_x402_accepts_for_402
+
+x402_accepts = build_x402_accepts_for_402(
+    x402_server,
+    network=X402_BASE,
+    price=f"${total_usd}",
+    pay_to=os.environ["TREASURY_BASE_RECIPIENT"],
+    max_timeout_seconds=300,
+)
+```
+
+Returns a list of plain dicts ready for the 402 body's `accepts[]`. `extra.name` is derived from the registered scheme metadata so the EIP-712 domain matches the on-chain USDC contract.
+
 ## Drop-in 402 + settle (x402)
 
 ```python

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/agentscore_commerce/discovery/probe.py

@@ -39,7 +39,11 @@ def sample_x402_accept_for_network(caip2: str, amount_atomic: str = "1000000") -
             "asset": USDC.base.mainnet.address,
             "payTo": _ZERO_EVM_PAYTO,
             "maxTimeoutSeconds": 300,
-            "extra": {"name": "USDC", "version": "2"},
+            # ``extra.name`` mirrors the on-chain USDC contract's ``name()`` return value
+            # because EIP-712 domain hashes include this string. Wrong name → every
+            # signed payload fails facilitator verify with ``invalid_exact_evm_payload_signature``.
+            # Base mainnet USDC returns "USD Coin"; base sepolia USDC returns "USDC".
+            "extra": {"name": "USD Coin", "version": "2"},
         }
     if caip2 == networks.base.sepolia.caip2:
         return {

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/agentscore_commerce/payment/__init__.py

@@ -52,6 +52,7 @@ from agentscore_commerce.payment.x402_server import (
     CustomScheme,
     X402FacilitatorChoice,
     X402SymbolicRail,
+    build_x402_accepts_for_402,
     create_x402_server,
 )
 from agentscore_commerce.payment.x402_settle import (
@@ -61,7 +62,10 @@ from agentscore_commerce.payment.x402_settle import (
     ProcessX402SettleResult,
     ProcessX402SettleSuccess,
     classify_x402_settle_result,
+    coerce_payment_payload,
+    coerce_resource_config,
     process_x402_settle,
+    settle_result_to_json_bytes,
 )
 from agentscore_commerce.payment.x402_validation import (
     X402_SUPPORTED_BASE_NETWORKS,
@@ -114,7 +118,10 @@ __all__ = [
     "build_payment_directive",
     "build_payment_headers",
     "build_payment_request_blob",
+    "build_x402_accepts_for_402",
     "classify_x402_settle_result",
+    "coerce_payment_payload",
+    "coerce_resource_config",
     "create_mppx_server",
     "create_x402_server",
     "dispatch_settlement_by_network",
@@ -130,6 +137,7 @@ __all__ = [
     "rails",
     "read_x402_payment_header",
     "register_x402_schemes_v1_v2",
+    "settle_result_to_json_bytes",
     "settlement_override_header",
     "validate_x402_network_config",
     "verify_x402_request",

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/agentscore_commerce/payment/x402_server.py

@@ -266,10 +266,75 @@ async def create_x402_server(
     return server
 
 
+def build_x402_accepts_for_402(
+    server: Any,
+    *,
+    network: str,
+    price: str,
+    pay_to: str,
+    scheme: str = "exact",
+    max_timeout_seconds: int = 300,
+    extensions: list[str] | None = None,
+) -> list[dict[str, Any]]:
+    """Build x402 ``accepts[]`` entries for a 402 challenge body.
+
+    Wraps ``server.build_payment_requirements(...)`` so merchants don't have to:
+
+    1. Import ``x402.schemas.config.ResourceConfig`` themselves
+    2. Remember to call ``model_dump(by_alias=True, mode="json")`` on each Pydantic
+       requirement so the surrounding JSON response can serialize it
+    3. Hardcode ``extra`` (which differs by the actual on-chain contract: base mainnet
+       USDC has ``name="USD Coin"``, base sepolia USDC has ``name="USDC"`` — EIP-712
+       domain hashes differ, so getting this wrong silently breaks every signature
+       verify at the facilitator)
+
+    Returns a list of plain dicts in the shape that x402 expects on the wire — drop
+    them straight into the ``accepts`` field of the 402 challenge body.
+
+    Raises ``Exception`` if the underlying ``build_payment_requirements`` raises;
+    callers should wrap with ``try/except`` and either omit x402 from the 402 or
+    surface a 5xx (depending on whether other rails are advertised).
+    """
+    config_cls_module = _import_optional("x402.schemas.config")
+    config_cls = getattr(config_cls_module, "ResourceConfig", None) if config_cls_module else None
+    if config_cls is None:
+        msg = "x402 not installed — run `pip install 'x402[evm,fastapi]>=2.9,<3'` to use build_x402_accepts_for_402."
+        raise ImportError(msg)
+    config = config_cls(
+        scheme=scheme,
+        network=network,
+        price=price,
+        pay_to=pay_to,
+        max_timeout_seconds=max_timeout_seconds,
+    )
+    requirements = (
+        server.build_payment_requirements(config, extensions)
+        if extensions
+        else server.build_payment_requirements(config)
+    )
+    # Pydantic ``PaymentRequirements`` is the live shape under x402 2.9+. Older
+    # versions (and test stubs) return plain dicts that already match the wire form.
+    out: list[dict[str, Any]] = []
+    for req in requirements:
+        model_dump = getattr(req, "model_dump", None)
+        if callable(model_dump):
+            out.append(model_dump(by_alias=True, mode="json"))
+        elif isinstance(req, dict):
+            out.append(dict(req))
+        else:
+            msg = (
+                f"build_payment_requirements returned {type(req).__name__}; expected a "
+                "Pydantic PaymentRequirements or a dict."
+            )
+            raise TypeError(msg)
+    return out
+
+
 __all__ = [
     "CreateX402ServerOptions",
     "CustomScheme",
     "X402FacilitatorChoice",
     "X402SymbolicRail",
+    "build_x402_accepts_for_402",
     "create_x402_server",
 ]

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/agentscore_commerce/payment/x402_settle.py

@@ -189,7 +189,7 @@ def classify_x402_settle_result(result: ProcessX402SettleResult) -> ClassifiedX4
     return None
 
 
-def _coerce_resource_config(config: Any) -> Any:
+def coerce_resource_config(config: Any) -> Any:
     """Best-effort dict → x402 ``ResourceConfig`` coercion.
 
     Consumers ported from the JS / Hono stack often pass a plain dict with the JS-style
@@ -220,10 +220,40 @@ def _coerce_resource_config(config: Any) -> Any:
         return config
 
 
+def coerce_payment_payload(payload: Any) -> Any:
+    """Best-effort dict → x402 ``PaymentPayload`` (v1 or v2) coercion.
+
+    ``verify_x402_request`` returns ``payload`` as a plain dict (the result of
+    ``json.loads(base64.b64decode(X-Payment))``), but x402 2.9's
+    ``server.verify_payment`` / ``server.settle_payment`` call ``payload.get_scheme()``
+    and other typed-model methods on it. Without coercion, the dict raises
+    ``AttributeError("'dict' object has no attribute 'get_scheme'")`` on the verify leg.
+
+    Routes by the ``x402Version`` field: ``1`` → ``PaymentPayloadV1`` (flat shape with
+    top-level ``scheme`` / ``network``); anything else → ``PaymentPayload`` (v2 shape
+    nested under ``accepted``). Falls back to the original dict on any failure so callers
+    that already pass typed instances or unusual shapes still flow through unchanged.
+    """
+    if not isinstance(payload, dict):
+        return payload
+    try:
+        from x402.schemas import PaymentPayload
+        from x402.schemas.v1 import PaymentPayloadV1
+    except ImportError:
+        return payload
+    version = payload.get("x402Version")
+    model = PaymentPayloadV1 if version == 1 else PaymentPayload
+    try:
+        return model.model_validate(payload)
+    except Exception:
+        return payload
+
+
 async def process_x402_settle(input: ProcessX402SettleInput) -> ProcessX402SettleResult:
     """Run the x402 verify→settle flow and return a tagged outcome."""
     server = input.x402_server
-    resource_config = _coerce_resource_config(input.resource_config)
+    resource_config = coerce_resource_config(input.resource_config)
+    payload = coerce_payment_payload(input.payload)
 
     try:
         built_requirements = server.build_payment_requirements(resource_config)
@@ -267,7 +297,7 @@ async def process_x402_settle(input: ProcessX402SettleInput) -> ProcessX402Settl
     # — not ``process_payment_request`` (a fictional method that earlier versions of this
     # helper called and only ever worked against test stubs).
     try:
-        verify_result = await server.verify_payment(input.payload, matched_requirement)
+        verify_result = await server.verify_payment(payload, matched_requirement)
     except Exception as err:
         return ProcessX402SettleFailure(phase="facilitator_error", step="verify_payment", error=err)
 
@@ -288,11 +318,10 @@ async def process_x402_settle(input: ProcessX402SettleInput) -> ProcessX402Settl
         return ProcessX402SettleFailure(phase="verify_failed", verify_result=verify_result)
 
     try:
-        settle_result = await server.settle_payment(input.payload, matched_requirement)
+        settle_result = await server.settle_payment(payload, matched_requirement)
         payment_response_header: str | None = None
         if settle_result is not None:
-            payload_bytes = json.dumps(settle_result, separators=(",", ":")).encode()
-            payment_response_header = base64.b64encode(payload_bytes).decode()
+            payment_response_header = base64.b64encode(settle_result_to_json_bytes(settle_result)).decode()
         return ProcessX402SettleSuccess(
             matched_requirement=matched_requirement,
             settle_result=settle_result,
@@ -301,3 +330,19 @@ async def process_x402_settle(input: ProcessX402SettleInput) -> ProcessX402Settl
         )
     except Exception as err:
         return ProcessX402SettleFailure(phase="settle_failed", error=err, matched_requirement=matched_requirement)
+
+
+def settle_result_to_json_bytes(settle_result: Any) -> bytes:
+    """Serialize the settle result to a base64-friendly JSON byte string.
+
+    x402 2.9's ``settle_payment`` returns a Pydantic ``SettleResponse`` model that
+    ``json.dumps`` rejects with ``TypeError: Object of type SettleResponse is not
+    JSON serializable``. Use ``model_dump_json(by_alias=True)`` for Pydantic models
+    (so emitted keys match the wire shape — ``errorReason`` / ``errorMessage`` rather
+    than the snake_case attrs) and fall through to ``json.dumps`` for plain dicts
+    (used by older x402 / test stubs).
+    """
+    model_dump_json = getattr(settle_result, "model_dump_json", None)
+    if callable(model_dump_json):
+        return model_dump_json(by_alias=True).encode()
+    return json.dumps(settle_result, separators=(",", ":")).encode()

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/examples/api_provider.py

@@ -128,8 +128,16 @@ async def search(request: Request):
                 "payTo": os.environ["X402_BASE_RECIPIENT"],
                 "maxTimeoutSeconds": 300,
                 # EIP-712 domain required by every x402 EVM client to sign
-                # EIP-3009 TransferWithAuthorization.
-                "extra": {"name": "USDC", "version": "2"},
+                # EIP-3009 TransferWithAuthorization. ``name`` MUST match the
+                # on-chain USDC contract's ``name()`` — base mainnet returns
+                # "USD Coin", base sepolia returns "USDC". Wrong value silently
+                # breaks signature verify at the facilitator. Production code
+                # should use ``build_x402_accepts_for_402(server, ...)`` which
+                # derives ``extra`` from the registered scheme metadata.
+                "extra": {
+                    "name": "USD Coin" if X402_BASE_NETWORK.split(":")[-1] == "8453" else "USDC",
+                    "version": "2",
+                },
             },
         ]
         return JSONResponse(

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/examples/multi_rail_merchant.py

@@ -69,6 +69,7 @@ from agentscore_commerce.payment import (
     ProcessX402SettleInput,
     ValidateX402NetworkConfigInput,
     VerifyX402RequestInput,
+    build_x402_accepts_for_402,
     networks,
     process_x402_settle,
     validate_x402_network_config,
@@ -250,24 +251,17 @@ async def purchase(request: Request, assess: dict = Depends(get_assess_data)):
             ),
             x402=PaymentRequiredHeaderInput(
                 x402_version=2,
+                # Base accept comes from the registered x402 scheme — `extra` (incl. the
+                # network-correct USDC `name`) is filled in automatically. Solana goes
+                # through MPP `solana/charge` not x402's exact scheme, so it stays inline.
                 accepts=[
-                    {
-                        "scheme": "exact",
-                        "network": X402_BASE_NETWORK,
-                        "amount": str(round(float(total_usd) * 1_000_000)),
-                        # Asset must match the configured network — sepolia + mainnet
-                        # use different USDC contracts.
-                        "asset": (
-                            USDC.base.sepolia.address
-                            if networks.base.sepolia.caip2 == X402_BASE_NETWORK
-                            else USDC.base.mainnet.address
-                        ),
-                        "payTo": deposit_addresses["base"],
-                        "maxTimeoutSeconds": 300,
-                        # EIP-712 domain — required by every x402 EVM client to
-                        # sign EIP-3009 TransferWithAuthorization.
-                        "extra": {"name": "USDC", "version": "2"},
-                    },
+                    *build_x402_accepts_for_402(
+                        x402_server,
+                        network=X402_BASE_NETWORK,
+                        price=f"${total_usd}",
+                        pay_to=deposit_addresses["base"],
+                        max_timeout_seconds=300,
+                    ),
                     {
                         "scheme": "exact",
                         "network": SOLANA_NETWORK_CAIP2,

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentscore-commerce"
-version = "1.3.2"
+version = "1.3.4"
 description = "Agent commerce SDK for Python — identity middleware (FastAPI, Flask, Django, AIOHTTP, Sanic, ASGI) + payment helpers + 402 builders + discovery + Stripe multichain. The full merchant-side toolkit for AgentScore-powered agent commerce."
 readme = "README.md"
 license = "MIT"

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/tests/test_discovery.py

@@ -176,7 +176,9 @@ def test_sample_accept_base_mainnet() -> None:
     assert e is not None
     assert e["network"] == "eip155:8453"
     assert e["scheme"] == "exact"
-    assert e["extra"] == {"name": "USDC", "version": "2"}
+    # Base mainnet USDC's contract returns ``name() == "USD Coin"``. ``extra.name``
+    # mirrors that for EIP-712 domain-hash parity with what the facilitator validates.
+    assert e["extra"] == {"name": "USD Coin", "version": "2"}
 
 
 def test_sample_accept_base_sepolia() -> None:
@@ -185,6 +187,8 @@ def test_sample_accept_base_sepolia() -> None:
     e = sample_x402_accept_for_network("eip155:84532")
     assert e is not None
     assert e["network"] == "eip155:84532"
+    # Base sepolia USDC contract returns ``name() == "USDC"`` (differs from mainnet).
+    assert e["extra"] == {"name": "USDC", "version": "2"}
 
 
 def test_sample_accept_solana_mainnet() -> None:

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/tests/test_lifted_helpers.py

@@ -534,6 +534,220 @@ async def test_process_x402_settle_passes_typed_resource_config_unchanged():
     assert captured["cfg"] is typed
 
 
+@pytest.mark.asyncio
+async def test_process_x402_settle_coerces_dict_payload_v2_to_typed_payment_payload():
+    """Same fix as resource_config: ``verify_x402_request`` returns ``payload`` as a
+    plain dict (the result of ``json.loads(base64.b64decode(X-Payment))``); x402 2.9's
+    ``server.verify_payment`` calls ``payload.get_scheme()`` and other typed-model methods
+    on it. Coerce dicts → ``PaymentPayload`` (or ``PaymentPayloadV1`` when ``x402Version=1``)
+    so the helper doesn't ``AttributeError`` at the verify leg.
+    """
+    captured: dict = {}
+
+    class _CapturingServer:
+        def build_payment_requirements(self, _cfg: object, _ext: object = None) -> list:
+            return [{"id": "req1"}]
+
+        async def verify_payment(self, payload: object, _req: object) -> dict:
+            captured["verify_payload"] = payload
+            return {"is_valid": True}
+
+        async def settle_payment(self, payload: object, _req: object) -> dict:
+            captured["settle_payload"] = payload
+            return {"tx_hash": "0xabc"}
+
+    payload_dict = {
+        "x402Version": 2,
+        "accepted": {
+            "scheme": "exact",
+            "network": "eip155:8453",
+            "amount": "100000",
+            "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+            "payTo": "0x000000000000000000000000000000000000dEaD",
+            "maxTimeoutSeconds": 300,
+        },
+        "payload": {
+            "authorization": {
+                "from": "0xeb2Ca790F72787c7e61bC6c861353a1e4ACDFCa5",
+                "to": "0x000000000000000000000000000000000000dEaD",
+                "value": "100000",
+                "validAfter": 0,
+                "validBefore": 9999999999,
+                "nonce": "0x" + "aa" * 32,
+            },
+            "signature": "0x" + "cc" * 65,
+        },
+    }
+    res = await process_x402_settle(
+        ProcessX402SettleInput(
+            x402_server=_CapturingServer(),
+            payload=payload_dict,
+            resource_config={
+                "scheme": "exact",
+                "network": "eip155:8453",
+                "price": "$0.10",
+                "payTo": "0x" + "00" * 19 + "dE" + "aD",
+                "maxTimeoutSeconds": 300,
+            },
+            resource_meta=_RESOURCE_META,
+        )
+    )
+    assert isinstance(res, ProcessX402SettleSuccess)
+    # Both verify and settle legs received the typed Pydantic model, not the raw dict.
+    verify_payload = captured["verify_payload"]
+    settle_payload = captured["settle_payload"]
+    assert type(verify_payload).__name__ == "PaymentPayload"
+    assert type(settle_payload).__name__ == "PaymentPayload"
+    # The typed model exposes the get_scheme() method that x402's facilitator calls.
+    assert hasattr(verify_payload, "get_scheme")
+    assert verify_payload.get_scheme() == "exact"
+
+
+@pytest.mark.asyncio
+async def test_process_x402_settle_serializes_pydantic_settle_result_to_payment_response_header():
+    """x402 2.9's ``settle_payment`` returns a Pydantic ``SettleResponse`` model;
+    plain ``json.dumps`` rejects it with ``TypeError``. The helper must call
+    ``model_dump_json(by_alias=True)`` so the X-Payment-Response header stays
+    base64'd JSON with the right wire keys (``errorReason`` not ``error_reason``).
+    """
+    from x402.schemas import SettleResponse
+
+    pydantic_settle = SettleResponse(
+        success=True,
+        transaction="0xabc",
+        network="eip155:8453",
+        payer="0x000000000000000000000000000000000000dEaD",
+        amount=None,
+    )
+
+    class _PydanticSettleServer:
+        def build_payment_requirements(self, _cfg: object, _ext: object = None) -> list:
+            return [{"id": "req1"}]
+
+        async def verify_payment(self, _payload: object, _req: object) -> dict:
+            return {"is_valid": True}
+
+        async def settle_payment(self, _payload: object, _req: object) -> SettleResponse:
+            return pydantic_settle
+
+    res = await process_x402_settle(
+        ProcessX402SettleInput(
+            x402_server=_PydanticSettleServer(),
+            payload={},
+            resource_config={
+                "scheme": "exact",
+                "network": "eip155:8453",
+                "price": "$0.10",
+                "payTo": "0x" + "00" * 19 + "dE" + "aD",
+                "maxTimeoutSeconds": 300,
+            },
+            resource_meta=_RESOURCE_META,
+        )
+    )
+    assert isinstance(res, ProcessX402SettleSuccess)
+    assert res.payment_response_header is not None
+    decoded = json.loads(base64.b64decode(res.payment_response_header).decode())
+    assert decoded["success"] is True
+    assert decoded["transaction"] == "0xabc"
+    assert decoded["network"] == "eip155:8453"
+    # by_alias=True: wire shape uses errorReason / errorMessage (camelCase) — not snake_case.
+    assert "errorReason" in decoded
+
+
+@pytest.mark.asyncio
+async def test_process_x402_settle_serializes_dict_settle_result_for_legacy_stubs():
+    """Plain-dict settle results (from older x402 / test stubs) still serialize."""
+
+    class _DictSettleServer:
+        def build_payment_requirements(self, _cfg: object, _ext: object = None) -> list:
+            return [{"id": "req1"}]
+
+        async def verify_payment(self, _payload: object, _req: object) -> dict:
+            return {"is_valid": True}
+
+        async def settle_payment(self, _payload: object, _req: object) -> dict:
+            return {"success": True, "transaction": "0xdef"}
+
+    res = await process_x402_settle(
+        ProcessX402SettleInput(
+            x402_server=_DictSettleServer(),
+            payload={},
+            resource_config={
+                "scheme": "exact",
+                "network": "eip155:8453",
+                "price": "$0.10",
+                "payTo": "0x" + "00" * 19 + "dE" + "aD",
+                "maxTimeoutSeconds": 300,
+            },
+            resource_meta=_RESOURCE_META,
+        )
+    )
+    assert isinstance(res, ProcessX402SettleSuccess)
+    assert res.payment_response_header is not None
+    decoded = json.loads(base64.b64decode(res.payment_response_header).decode())
+    assert decoded == {"success": True, "transaction": "0xdef"}
+
+
+@pytest.mark.asyncio
+async def test_process_x402_settle_passes_typed_payment_payload_unchanged():
+    """If the caller already provides a typed PaymentPayload, pass it through unchanged."""
+    from x402.schemas import PaymentPayload
+
+    typed = PaymentPayload.model_validate(
+        {
+            "x402Version": 2,
+            "accepted": {
+                "scheme": "exact",
+                "network": "eip155:8453",
+                "amount": "100000",
+                "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                "payTo": "0x000000000000000000000000000000000000dEaD",
+                "maxTimeoutSeconds": 300,
+            },
+            "payload": {
+                "authorization": {
+                    "from": "0xeb2Ca790F72787c7e61bC6c861353a1e4ACDFCa5",
+                    "to": "0x000000000000000000000000000000000000dEaD",
+                    "value": "100000",
+                    "validAfter": 0,
+                    "validBefore": 9999999999,
+                    "nonce": "0x" + "aa" * 32,
+                },
+                "signature": "0x" + "cc" * 65,
+            },
+        }
+    )
+    captured: dict = {}
+
+    class _CapturingServer:
+        def build_payment_requirements(self, _cfg: object, _ext: object = None) -> list:
+            return [{"id": "req1"}]
+
+        async def verify_payment(self, payload: object, _req: object) -> dict:
+            captured["payload"] = payload
+            return {"is_valid": True}
+
+        async def settle_payment(self, _payload: object, _req: object) -> dict:
+            return {"tx_hash": "0xabc"}
+
+    res = await process_x402_settle(
+        ProcessX402SettleInput(
+            x402_server=_CapturingServer(),
+            payload=typed,
+            resource_config={
+                "scheme": "exact",
+                "network": "eip155:8453",
+                "price": "$0.10",
+                "payTo": "0x" + "00" * 19 + "dE" + "aD",
+                "maxTimeoutSeconds": 300,
+            },
+            resource_meta=_RESOURCE_META,
+        )
+    )
+    assert isinstance(res, ProcessX402SettleSuccess)
+    assert captured["payload"] is typed
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # process_x402_settle: facilitator_error wrap
 # ─────────────────────────────────────────────────────────────────────────────

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/tests/test_payment_servers.py

@@ -91,6 +91,56 @@ async def test_create_x402_server_coinbase_without_creds_raises(monkeypatch: pyt
         await create_x402_server(facilitator="coinbase", rails=["x402-base-mainnet"], initialize=False)
 
 
+@pytest.mark.skipif(not _X402_INSTALLED, reason="x402 peer dep not installed")
+def test_build_x402_accepts_for_402_returns_dicts_from_typed_requirements() -> None:
+    """``build_x402_accepts_for_402`` wraps ``server.build_payment_requirements`` and
+    returns the requirements as wire-shape dicts (via ``model_dump(by_alias=True, mode="json")``)
+    so merchants can drop them straight into the 402 response body without importing
+    Pydantic types or remembering to serialize.
+    """
+    from x402.schemas import PaymentRequirements
+
+    from agentscore_commerce.payment import build_x402_accepts_for_402
+
+    captured: dict = {}
+
+    class _CapturingServer:
+        def build_payment_requirements(self, config, _ext=None):
+            captured["config"] = config
+            return [
+                PaymentRequirements(
+                    scheme="exact",
+                    network="eip155:8453",
+                    amount="100000",
+                    asset="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                    pay_to="0x000000000000000000000000000000000000dEaD",
+                    max_timeout_seconds=300,
+                    extra={"name": "USD Coin", "version": "2"},
+                )
+            ]
+
+    accepts = build_x402_accepts_for_402(
+        _CapturingServer(),
+        network="eip155:8453",
+        price="$0.10",
+        pay_to="0x000000000000000000000000000000000000dEaD",
+    )
+    # Caller-side: a typed ResourceConfig is passed to build_payment_requirements.
+    cfg = captured["config"]
+    assert cfg.network == "eip155:8453"
+    assert cfg.pay_to == "0x000000000000000000000000000000000000dEaD"
+    assert cfg.max_timeout_seconds == 300
+    # Returned shape: wire-form dicts, not Pydantic models.
+    assert isinstance(accepts, list)
+    assert len(accepts) == 1
+    assert isinstance(accepts[0], dict)
+    assert accepts[0]["network"] == "eip155:8453"
+    # Camel-case keys (by_alias=True) — facilitator + clients expect this shape.
+    assert accepts[0]["payTo"] == "0x000000000000000000000000000000000000dEaD"
+    assert accepts[0]["maxTimeoutSeconds"] == 300
+    assert accepts[0]["extra"] == {"name": "USD Coin", "version": "2"}
+
+
 @pytest.mark.skipif(not _MPPX_INSTALLED or not _TEMPO_INSTALLED, reason="pympp[tempo] not installed")
 @pytest.mark.asyncio
 async def test_create_mppx_server_tempo_returns_mpp_instance() -> None:

{agentscore_commerce-1.3.2 → agentscore_commerce-1.3.4}/uv.lock

@@ -10,7 +10,7 @@ resolution-markers = [
 
 [[package]]
 name = "agentscore-commerce"
-version = "1.3.2"
+version = "1.3.4"
 source = { editable = "." }
 dependencies = [
     { name = "agentscore-py" },