@4mica/x402 1.2.4 → 2.0.0-alpha.2

package/CHANGELOG.md

@@ -1,6 +1,68 @@
-# Changelog
+# @4mica/x402
+
+## 2.0.0-alpha.2
+
+### Major Changes
+
+- 70d83f9: First release on `@4mica/sdk` 2.0 and the tab-free protocol.
+
+  - The tab handshake is gone: clients sign their claim straight from the payment
+    requirements with a random 32-byte `reqId`. `FourMicaFacilitatorClient.openTab`,
+    the `OpenTab*` types, the Express middlewares' `tabConfig` parameter and the
+    server scheme's `advertisedTabEndpoint` are removed. The flat ERC-8004 policy
+    types are replaced by `FourMicaRequirementsExtra` with a nested `validation`.
+  - Server: a `Money` price (`"$0.10"`) resolves to the stablecoin 4mica core lists
+    for the network (`GET /core/tokens`) instead of a hardcoded USDC table, so the
+    advertised `asset` is always one core accepts. `new FourMicaEvmScheme({
+coreUrls?, stablecoinSymbol? })` points a network at a self-hosted core or
+    picks another listed token. The EIP-3009 `name` / `version` hints in `extra`
+    are gone: a 4mica-credit payer signs against core's guarantee domain.
+  - Client: `FourMicaEvmScheme.create(account, { coreUrls?, networks? })`
+    overrides a network's core and limits the up-front connections. The scheme
+    implements `findDefaultAsset` from core's token list, so `@x402/fetch` spend
+    controls accept the advertised asset and apply their USD cap to it.
+  - Express: the middlewares no longer overwrite a scheme server the caller
+    registered for a hosted network, so a self-hosted core on a hosted chain id
+    works.
+  - Supported networks: Base (`eip155:8453`) and Base Sepolia (`eip155:84532`)
+    for x402 v1 and v2; Ethereum Sepolia for v1 only.
+
+### Minor Changes
+
+- 9136814: The server scheme advertises core's EIP-712 domain on every requirement, as
+  `extra.name`, `extra.version` and `extra.verifyingContract` (`eip712_name`,
+  `eip712_version` and `contract_address` from `GET /core/public-params`, fetched
+  once per network). The client signs from those fields when they are present
+  instead of connecting to core, taking the chain id from `network`, so a payer
+  needs no core URL for a seller that advertises them. Requirements without them
+  are signed as before.
+
+### Patch Changes
+
+- Updated dependencies [34eada6]
+- Updated dependencies [8998b02]
+- Updated dependencies [6b0974a]
+  - @4mica/sdk@2.0.0-alpha.0
+
+## 2.0.0-alpha.1
+
+- Breaking: migrate to `@4mica/sdk` 2.0 and the tab-free protocol. The tab
+  handshake is gone — clients sign their claim straight from the payment
+  requirements with a random 32-byte `reqId`.
+- Breaking: `FourMicaEvmScheme` (server) takes no `advertisedTabEndpoint`;
+  `enhancePaymentRequirements` no longer injects `extra.tabEndpoint`.
+- Breaking: the Express middlewares lose their `tabConfig` parameter and the
+  tab-open route interception.
+- Breaking: `FourMicaFacilitatorClient.openTab`, `OpenTabRequest`,
+  `OpenTabResponse`, and `OpenTabError` are removed (`POST /tabs` no longer
+  exists).
+- Breaking: `FourMicaV2RequirementsExtra` / `FourMicaPaymentRequirementsV2`
+  (the flat ERC-8004 validation policy) are replaced by
+  `FourMicaRequirementsExtra` with a nested `validation`
+  (`{ validator, subject, deadline?, params? }`).
 
 ## 0.3.0
+
 - Breaking: include `reqId` in `PaymentGuaranteeRequestClaims` and signing payloads (EIP-712/EIP-191).
 - Breaking: X402 envelopes now emit `req_id` and `TabResponse` exposes `nextReqId` for claim building.
 - Fix: `listRecipientTabs` query parameter uses `settlement_status` to match core API.

package/README.md

@@ -25,15 +25,11 @@ app.use(
         accepts: {
           scheme: "4mica-credit",
           price: "$0.10",
-          network: "eip155:11155111", // Ethereum Sepolia
+          network: "eip155:84532", // Base Sepolia
           payTo: "0xYourAddress",
         },
         description: "Access to premium content",
       },
-    },
-    // Payment tab config
-    {
-      advertisedEndpoint: "https://api.example.com/tabs/open",
     }
   )
 );
@@ -69,7 +65,7 @@ const scheme = await FourMicaEvmScheme.create(account);
 const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
   schemes: [
     {
-      network: "eip155:11155111", // Ethereum Sepolia
+      network: "eip155:84532", // Base Sepolia
       client: scheme,
     },
   ],
@@ -81,6 +77,11 @@ const data = await response.json();
 console.log(data);
 ```
 
+`@x402/fetch` only pays in assets the scheme client recognises. `FourMicaEvmScheme` recognises
+whatever 4mica core lists for the network (`GET /core/tokens`), so the server's advertised USDC
+passes the client's spend controls and the default `$1` per-payment cap applies to it. Pass
+`spendControls` to change the cap or allow other assets.
+
 ### Using with Axios
 
 Use with `@x402/axios` for Axios-based applications:
@@ -101,7 +102,7 @@ const scheme = await FourMicaEvmScheme.create(account);
 const api = wrapAxiosWithPaymentFromConfig(axios.create(), {
   schemes: [
     {
-      network: "eip155:11155111", // Ethereum Sepolia
+      network: "eip155:84532", // Base Sepolia
       client: scheme,
     },
   ],
@@ -115,7 +116,7 @@ console.log(data);
 
 ## Server Configuration
 
-### `paymentMiddlewareFromConfig(routes, tabConfig, ...options)`
+### `paymentMiddlewareFromConfig(routes, ...options)`
 
 The recommended middleware factory for most use cases. Automatically configures the 4mica facilitator and registers the `FourMicaEvmScheme` for all supported networks.
 
@@ -129,7 +130,7 @@ The recommended middleware factory for most use cases. Automatically configures
     accepts: {
       scheme: "4mica-credit",
       price: "$0.10",
-      network: "eip155:11155111", // or "eip155:80002" for Polygon Amoy
+      network: "eip155:84532", // or "eip155:8453" for Base mainnet
       payTo: "0xRecipientAddress",
     },
     description: "What the user is paying for",
@@ -137,45 +138,40 @@ The recommended middleware factory for most use cases. Automatically configures
 }
 ```
 
-2. **`tabConfig`** (required): Payment tab configuration
-
-```typescript
-{
-  // Full URL endpoint for opening payment tabs
-  // This is injected into paymentRequirements.extra and clients use it to open tabs
-  advertisedEndpoint: "https://api.example.com/tabs/open",
-  
-  // Lifetime of payment tabs in seconds
-  ttlSeconds: 3600, // optional, defaults to facilitator's default
-}
-```
+2. **`facilitatorClients`** (optional): Additional facilitator client(s) for other payment schemes
+3. **`schemes`** (optional): Additional scheme registrations for other networks/schemes
+4. **`paywallConfig`** (optional): Configuration for the built-in paywall UI
+5. **`paywall`** (optional): Custom paywall provider
+6. **`syncFacilitatorOnStart`** (optional): Whether to sync with facilitator on startup (defaults to true)
 
-3. **`facilitatorClients`** (optional): Additional facilitator client(s) for other payment schemes
-4. **`schemes`** (optional): Additional scheme registrations for other networks/schemes
-5. **`paywallConfig`** (optional): Configuration for the built-in paywall UI
-6. **`paywall`** (optional): Custom paywall provider
-7. **`syncFacilitatorOnStart`** (optional): Whether to sync with facilitator on startup (defaults to true)
+#### Validation-gated payments
 
-#### V2 Requirements Extra
-
-When using x402 V2, `paymentRequirements.extra` must include the validation policy fields expected by the 4mica SDKs and facilitator:
+To gate a payment on an external validator, advertise a nested `validation`
+object in `paymentRequirements.extra`. The payer signs the same requirement
+into their claims, and the guarantee only becomes payable once the validator
+approves it:
 
 ```typescript
 const extra = {
-  validationRegistryAddress: '0x3333333333333333333333333333333333333333',
-  validatorAddress: '0x4444444444444444444444444444444444444444',
-  validatorAgentId: '7',
-  minValidationScore: 80,
-  jobHash: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-  requiredValidationTag: 'hard-finality', // optional
-  tabEndpoint: 'https://api.example.com/tabs/open',
+  validation: {
+    validator: 'validator-id',         // must be on core's allowlist
+    subject: '0x…32-byte hash…',       // what the validator must approve
+    deadline: 1700000600,              // optional; core tightens it to the cycle cutoff
+    params: '0x…',                     // optional validator-specific policy bytes
+  },
 }
 ```
 
 #### Supported Networks
 
-- `eip155:11155111` - Ethereum Sepolia
-- `eip155:80002` - Polygon Amoy
+- `eip155:8453` - Base
+- `eip155:84532` - Base Sepolia
+- `eip155:11155111` - Ethereum Sepolia (x402 v1 only)
+
+A `price` such as `"$0.10"` resolves to the stablecoin 4mica core lists for the network
+(`GET /core/tokens`), so the advertised `asset` is always one core accepts. Pass
+`{ coreUrls: { "eip155:84532": "http://localhost:3000/" } }` to `new FourMicaEvmScheme(...)` and
+register it through the `schemes` parameter to point a network at a self-hosted core.
 
 ### Advanced Server Usage
 
@@ -208,17 +204,7 @@ const resourceServer = new x402ResourceServer([
 ])
   .register("eip155:8453", new ExactEvmScheme()); // Add Base mainnet with exact scheme
 
-app.use(
-  paymentMiddleware(
-    routes,
-    resourceServer,
-    {
-      advertisedEndpoint: "https://api.example.com/tabs/open",
-      ttlSeconds: 3600,
-    },
-    paywallConfig
-  )
-);
+app.use(paymentMiddleware(routes, resourceServer, paywallConfig));
 ```
 
 #### Using `paymentMiddlewareFromHTTPServer` with HTTP Hooks
@@ -242,16 +228,7 @@ const httpServer = new x402HTTPResourceServer(resourceServer, routes)
     console.log("Protected request:", context.path);
   });
 
-app.use(
-  paymentMiddlewareFromHTTPServer(
-    httpServer,
-    {
-      advertisedEndpoint: "https://api.example.com/tabs/open",
-      ttlSeconds: 3600,
-    },
-    paywallConfig
-  )
-);
+app.use(paymentMiddlewareFromHTTPServer(httpServer, paywallConfig));
 ```
 
 ## Client Configuration
@@ -262,23 +239,37 @@ app.use(
 import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
 import { FourMicaEvmScheme } from "@4mica/x402/client";
 
-const sepoliaScheme = await FourMicaEvmScheme.create(sepoliaAccount);
-const amoyScheme = await FourMicaEvmScheme.create(amoyAccount);
+const baseSepoliaScheme = await FourMicaEvmScheme.create(baseSepoliaAccount);
+const baseScheme = await FourMicaEvmScheme.create(baseAccount);
 
 const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
   schemes: [
     {
-      network: "eip155:11155111", // Ethereum Sepolia
-      client: sepoliaScheme,
+      network: "eip155:84532", // Base Sepolia
+      client: baseSepoliaScheme,
     },
     {
-      network: "eip155:80002", // Polygon Amoy
-      client: amoyScheme,
+      network: "eip155:8453", // Base mainnet
+      client: baseScheme,
     },
   ],
 });
 ```
 
+### Paying on a self-hosted core
+
+`FourMicaEvmScheme.create` connects to every hosted network up front. Pass `coreUrls` to
+override a network's core API URL and `networks` to limit the connections to the ones you use;
+a resource server can also steer payers with `extra.rpcUrl` in its requirements, which wins over
+both.
+
+```typescript
+const scheme = await FourMicaEvmScheme.create(account, {
+  coreUrls: { "eip155:84532": "http://localhost:3000/" },
+  networks: ["eip155:84532"],
+});
+```
+
 ### Using Builder Pattern
 
 ```typescript
@@ -288,7 +279,7 @@ import { FourMicaEvmScheme } from "@4mica/x402/client";
 const scheme = await FourMicaEvmScheme.create(account);
 
 const client = new x402Client()
-  .register("eip155:11155111", scheme);
+  .register("eip155:84532", scheme);
 
 const fetchWithPayment = wrapFetchWithPayment(fetch, client);
 ```
@@ -311,7 +302,7 @@ app.use(
         accepts: {
           scheme: "4mica-credit",
           price: "$0.05",
-          network: "eip155:11155111",
+          network: "eip155:84532",
           payTo: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
         },
         description: "API data access",
@@ -320,15 +311,11 @@ app.use(
         accepts: {
           scheme: "4mica-credit",
           price: "$0.20",
-          network: "eip155:11155111",
+          network: "eip155:84532",
           payTo: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
         },
         description: "Computation service",
       },
-    },
-    {
-      advertisedEndpoint: "https://api.example.com/tabs/open",
-      ttlSeconds: 7200, // 2 hours
     }
   )
 );
@@ -358,7 +345,7 @@ async function main() {
   const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
     schemes: [
       {
-        network: "eip155:11155111",
+        network: "eip155:84532",
         client: scheme,
       },
     ],
@@ -386,18 +373,16 @@ main();
 
 1. **Server Setup**: The middleware automatically registers the `FourMicaEvmScheme` and injects the 4mica facilitator client, so you don't need to configure them manually.
 
-2. **Tab Management**: When a client requests a protected resource, the middleware handles the tab lifecycle:
-   - The `advertisedEndpoint` is injected into `paymentRequirements.extra.tabEndpoint`
-   - Clients use this endpoint to open payment tabs
-   - The middleware automatically processes tab opening requests when they arrive at the advertised endpoint
-
-3. **Payment Flow**:
+2. **Payment Flow** (tab-free):
    - Client makes initial request to protected resource
    - Server responds with `402 Payment Required` including payment requirements
-   - Client requests a tab from the advertised endpoint
-   - Client signs a payment guarantee using the 4mica SDK
+   - Client signs a payment guarantee straight from those requirements using
+     the 4mica SDK — a random 32-byte `reqId` is minted locally; there is no
+     server round-trip before signing
    - Client retries the request with the payment payload
-   - Server verifies and settles the payment via the 4mica facilitator
+   - Server verifies and settles the payment via the 4mica facilitator, which
+     issues the BLS guarantee certificate and binds it to the open settlement
+     cycle
    - Server returns the protected resource
 
 ## License

package/dist/client/scheme.d.ts

@@ -1,11 +1,47 @@
-import { SchemeNetworkClient, PaymentRequirements, PaymentPayload } from '@x402/core/types';
-import { Account } from 'viem/accounts';
+import type { Network, PaymentPayload, PaymentRequirements, SchemeNetworkClient } from '@x402/core/types';
+import type { Account } from 'viem/accounts';
+export interface FourMicaEvmSchemeClientOptions {
+    /**
+     * Core API URL per network, overriding the hosted deployments in `@4mica/sdk`'s
+     * `NETWORKS`; set an entry to pay on a self-hosted core.
+     */
+    coreUrls?: Partial<Record<Network, string>>;
+    /**
+     * Networks to connect to up front. Defaults to every hosted network plus the
+     * keys of `coreUrls`. Any other network connects lazily on its first payment.
+     */
+    networks?: Network[];
+}
+/** What `findDefaultAsset` reports for an asset core lists: `@x402/core`'s `DefaultAsset`. */
+export interface FourMicaDefaultAsset {
+    asset: string;
+    decimals: number;
+    symbol: string;
+}
 export declare class FourMicaEvmScheme implements SchemeNetworkClient {
     private readonly signer;
-    private readonly x402Flows;
+    private readonly coreUrls;
     readonly scheme = "4mica-credit";
+    private readonly x402Flows;
+    private readonly tokensByRpcUrl;
+    private readonly domainFlows;
     private constructor();
     private static createX402Flow;
-    static create(signer: Account): Promise<FourMicaEvmScheme>;
+    /** Core's token list. Private static so tests can stub the network call. */
+    private static loadSupportedTokens;
+    static create(signer: Account, options?: FourMicaEvmSchemeClientOptions): Promise<FourMicaEvmScheme>;
+    findDefaultAsset(asset: string, network: Network): FourMicaDefaultAsset | undefined;
     createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, 'x402Version' | 'payload'>>;
+    private coreUrl;
+    /**
+     * The flow that signs `paymentRequirements`. A requirement that carries
+     * core's EIP-712 domain in `extra` is signed locally, with no call to core.
+     * Otherwise the payer connects to core: the one a resource server names in
+     * `extra.rpcUrl`, then the payer's own overrides, then the hosted deployment.
+     */
+    private flowForRequirements;
+    /** The flow for a core, connected and its token list loaded on first use. */
+    private flowFor;
+    /** A flow that signs under the domain the resource server advertised. */
+    private flowForDomain;
 }

package/dist/client/scheme.js

@@ -1,47 +1,55 @@
-import { Client, ConfigBuilder, X402Flow, } from '@4mica/sdk';
+import { Client, ConfigBuilder, CorePublicParameters, PaymentSigner, RpcProxy, resolveNetworkRpcUrl, PaymentRequirementsV2 as SdkPaymentRequirementsV2, X402Flow, X402PaymentRequired, X402ResourceInfo, } from '@4mica/sdk';
+import { chainIdOf, readDomainExtra } from '../domain.js';
 import { SUPPORTED_NETWORKS } from '../server/scheme.js';
-const NETWORK_RPC_URLS = {
-    'eip155:11155111': 'https://ethereum.sepolia.api.4mica.xyz',
-    'eip155:84532': 'https://base.sepolia.api.4mica.xyz',
-    'eip155:80002': 'https://api.4mica.xyz',
-};
 export class FourMicaEvmScheme {
-    constructor(signer, 
-    // rpcUrl -> x402Flow
-    x402Flows) {
+    constructor(signer, coreUrls) {
         this.signer = signer;
-        this.x402Flows = x402Flows;
+        this.coreUrls = coreUrls;
         this.scheme = '4mica-credit';
+        // rpcUrl -> x402Flow
+        this.x402Flows = new Map();
+        // rpcUrl -> the tokens that core accepts guarantees against
+        this.tokensByRpcUrl = new Map();
+        // chainId|name|version|verifyingContract -> a flow that signs without core
+        this.domainFlows = new Map();
     }
     static async createX402Flow(signer, rpcUrl) {
         const cfg = new ConfigBuilder().rpcUrl(rpcUrl).signer(signer).build();
-        const client = await Client.new(cfg);
+        const client = await Client.connect(cfg);
         return X402Flow.fromClient(client);
     }
-    static async create(signer) {
-        const x402Flows = new Map();
-        for (const network of SUPPORTED_NETWORKS) {
-            const rpcUrl = NETWORK_RPC_URLS[network];
-            if (!rpcUrl)
-                continue;
-            x402Flows.set(rpcUrl, await FourMicaEvmScheme.createX402Flow(signer, rpcUrl));
+    /** Core's token list. Private static so tests can stub the network call. */
+    static loadSupportedTokens(rpcUrl) {
+        return new RpcProxy(rpcUrl).getSupportedTokens();
+    }
+    static async create(signer, options = {}) {
+        const coreUrls = options.coreUrls ?? {};
+        const networks = options.networks ?? [
+            ...SUPPORTED_NETWORKS,
+            ...Object.keys(coreUrls),
+        ];
+        const scheme = new FourMicaEvmScheme(signer, coreUrls);
+        for (const network of new Set(networks)) {
+            const rpcUrl = scheme.coreUrl(network);
+            if (rpcUrl)
+                await scheme.flowFor(rpcUrl);
         }
-        return new FourMicaEvmScheme(signer, x402Flows);
+        return scheme;
+    }
+    findDefaultAsset(asset, network) {
+        const rpcUrl = this.coreUrl(network);
+        const tokens = rpcUrl ? this.tokensByRpcUrl.get(rpcUrl) : undefined;
+        const token = tokens?.find((entry) => entry.address.toLowerCase() === asset.toLowerCase());
+        if (!token || token.decimals === undefined)
+            return undefined;
+        return { asset: token.address, decimals: token.decimals, symbol: token.symbol };
     }
     async createPaymentPayload(x402Version, paymentRequirements) {
         const network = paymentRequirements.network;
         if (!network) {
             throw new Error('Network is required in PaymentRequirements');
         }
-        const rpcUrl = paymentRequirements.extra?.rpcUrl ?? NETWORK_RPC_URLS[network];
-        if (!rpcUrl) {
-            throw new Error(`No RPC URL configured for network ${network}`);
-        }
-        let x402Flow = this.x402Flows.get(rpcUrl);
-        if (!x402Flow) {
-            x402Flow = await FourMicaEvmScheme.createX402Flow(this.signer, rpcUrl);
-            this.x402Flows.set(rpcUrl, x402Flow);
-        }
+        const x402Flow = await this.flowForRequirements(paymentRequirements, network);
         if (x402Version === 1) {
             const signed = await x402Flow.signPayment(paymentRequirements, this.signer.address);
             return {
@@ -57,17 +65,17 @@ export class FourMicaEvmScheme {
                 paymentRequirements.extra.resource !== null
                 ? paymentRequirements.extra.resource
                 : {};
-            const resource = {
-                url: String(resourcePayload.url ?? ''),
-                description: String(resourcePayload.description ?? ''),
-                mimeType: String(resourcePayload.mimeType ?? ''),
-            };
-            const paymentRequired = {
+            const accepted = SdkPaymentRequirementsV2.fromRaw(paymentRequirements);
+            const paymentRequired = new X402PaymentRequired({
                 x402Version: 2,
-                resource,
-                accepts: [paymentRequirements],
-            };
-            const signed = await x402Flow.signPaymentV2(paymentRequired, paymentRequirements, this.signer.address);
+                resource: new X402ResourceInfo({
+                    url: String(resourcePayload.url ?? ''),
+                    description: String(resourcePayload.description ?? ''),
+                    mimeType: String(resourcePayload.mimeType ?? ''),
+                }),
+                accepts: [accepted],
+            });
+            const signed = await x402Flow.signPaymentV2(paymentRequired, accepted, this.signer.address);
             return {
                 x402Version: 2,
                 payload: signed.payload,
@@ -75,4 +83,54 @@ export class FourMicaEvmScheme {
         }
         throw new Error(`Unsupported x402Version: ${x402Version}`);
     }
+    coreUrl(network) {
+        return this.coreUrls[network] ?? resolveNetworkRpcUrl(network);
+    }
+    /**
+     * The flow that signs `paymentRequirements`. A requirement that carries
+     * core's EIP-712 domain in `extra` is signed locally, with no call to core.
+     * Otherwise the payer connects to core: the one a resource server names in
+     * `extra.rpcUrl`, then the payer's own overrides, then the hosted deployment.
+     */
+    async flowForRequirements(paymentRequirements, network) {
+        const domain = readDomainExtra(paymentRequirements.extra);
+        if (domain)
+            return this.flowForDomain(domain, network);
+        const rpcUrl = paymentRequirements.extra?.rpcUrl ?? this.coreUrl(network);
+        if (!rpcUrl) {
+            throw new Error(`No core API URL known for network ${network}`);
+        }
+        return this.flowFor(rpcUrl);
+    }
+    /** The flow for a core, connected and its token list loaded on first use. */
+    async flowFor(rpcUrl) {
+        let x402Flow = this.x402Flows.get(rpcUrl);
+        if (!x402Flow) {
+            x402Flow = await FourMicaEvmScheme.createX402Flow(this.signer, rpcUrl);
+            this.x402Flows.set(rpcUrl, x402Flow);
+            const { tokens } = await FourMicaEvmScheme.loadSupportedTokens(rpcUrl);
+            this.tokensByRpcUrl.set(rpcUrl, tokens);
+        }
+        return x402Flow;
+    }
+    /** A flow that signs under the domain the resource server advertised. */
+    flowForDomain(domain, network) {
+        const chainId = chainIdOf(network);
+        if (chainId === undefined) {
+            throw new Error(`Cannot derive an EIP-712 chain id from network ${network}`);
+        }
+        const key = [chainId, domain.name, domain.version, domain.verifyingContract.toLowerCase()].join('|');
+        let flow = this.domainFlows.get(key);
+        if (!flow) {
+            // Only the four domain fields matter for signing; the operator's BLS key
+            // is for verifying certificates, which this path never does.
+            const params = new CorePublicParameters(new Uint8Array(0), domain.verifyingContract, domain.name, domain.version, chainId);
+            const signer = new PaymentSigner(this.signer);
+            flow = new X402Flow({
+                signPayment: (claims, scheme) => signer.signRequest(params, claims, scheme),
+            });
+            this.domainFlows.set(key, flow);
+        }
+        return flow;
+    }
 }

package/dist/domain.d.ts

@@ -0,0 +1,12 @@
+import type { Network } from '@x402/core/types';
+import type { FourMicaDomainExtra } from './types.js';
+/** The `extra` keys that carry core's EIP-712 domain. */
+export declare const DOMAIN_EXTRA_KEYS: readonly ["name", "version", "verifyingContract"];
+/**
+ * The EIP-712 domain a 4mica-credit requirement carries in `extra`, or
+ * `undefined` when it carries none. A partial set is a misconfigured seller:
+ * it throws rather than silently signing under a domain fetched from elsewhere.
+ */
+export declare function readDomainExtra(extra: Record<string, unknown> | undefined): FourMicaDomainExtra | undefined;
+/** The chain id of an `eip155:*` CAIP-2 network; `undefined` for any other namespace. */
+export declare function chainIdOf(network: Network | string): number | undefined;

package/dist/domain.js

@@ -0,0 +1,30 @@
+/** The `extra` keys that carry core's EIP-712 domain. */
+export const DOMAIN_EXTRA_KEYS = ['name', 'version', 'verifyingContract'];
+/**
+ * The EIP-712 domain a 4mica-credit requirement carries in `extra`, or
+ * `undefined` when it carries none. A partial set is a misconfigured seller:
+ * it throws rather than silently signing under a domain fetched from elsewhere.
+ */
+export function readDomainExtra(extra) {
+    if (!extra)
+        return undefined;
+    const present = DOMAIN_EXTRA_KEYS.filter((key) => typeof extra[key] === 'string' && extra[key].length > 0);
+    if (present.length === 0)
+        return undefined;
+    if (present.length < DOMAIN_EXTRA_KEYS.length) {
+        const missing = DOMAIN_EXTRA_KEYS.filter((key) => !present.includes(key)).join(', ');
+        throw new Error(`4mica-credit requirements carry a partial EIP-712 domain in extra (missing ${missing})`);
+    }
+    return {
+        name: extra.name,
+        version: extra.version,
+        verifyingContract: extra.verifyingContract,
+    };
+}
+/** The chain id of an `eip155:*` CAIP-2 network; `undefined` for any other namespace. */
+export function chainIdOf(network) {
+    const [namespace, reference] = network.split(':');
+    if (namespace !== 'eip155' || !reference || !/^\d+$/.test(reference))
+        return undefined;
+    return Number(reference);
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export type { PaymentRequired, PaymentRequirements, PaymentPayload, Network, SchemeNetworkServer, } from '@x402/core/types';
-export type { FourMicaPaymentRequirementsV2, FourMicaV2RequirementsExtra } from './types.js';
+export type { Network, PaymentPayload, PaymentRequired, PaymentRequirements, SchemeNetworkServer, } from '@x402/core/types';
+export type { FourMicaPaymentRequirements, FourMicaRequirementsExtra, FourMicaValidationExtra, } from './types.js';

package/dist/server/express/adapter.d.ts

@@ -1,5 +1,5 @@
-import { HTTPAdapter } from '@x402/core/server';
-import { Request } from 'express';
+import type { HTTPAdapter } from '@x402/core/server';
+import type { Request } from 'express';
 /**
  * Express adapter implementation
  */