Merge pull request #831 from Merit-Systems/mason/bump-x402-version

bump x402 version

Author: fmhall

apps/scan/package.json

@@ -138,7 +138,6 @@
     "vaul": "^1.1.2",
     "viem": "catalog:",
     "wagmi": "^2.17.5",
-    "x402": "catalog:x402-v1",
     "zod": "catalog:",
     "zod3": "npm:zod@^3.24.2"
   },

apps/scan/src/lib/resources.ts

@@ -122,24 +122,37 @@ export const registerResource = async (
     );
   }
 
-  const mappedAccepts = x402Options
-    .map(opt => ({
-      scheme: (opt.scheme ?? 'exact') as 'exact',
-      network: normalizeChainId(opt.network).replace(
-        '-',
-        '_'
-      ) as AcceptsNetwork,
-      maxAmountRequired:
-        ('amount' in opt ? opt.amount : opt.maxAmountRequired) ?? '0',
-      payTo: opt.payTo ?? '',
-      asset: opt.asset,
-      maxTimeoutSeconds: opt.maxTimeoutSeconds ?? 60,
-      outputSchema: outputSchemaForDb,
-      extra: undefined,
-    }))
-    .filter(accept =>
-      (SUPPORTED_CHAINS as readonly string[]).includes(accept.network)
+  const allMappedAccepts = x402Options.map(opt => ({
+    scheme: (opt.scheme ?? 'exact') as 'exact',
+    network: normalizeChainId(opt.network).replace('-', '_') as AcceptsNetwork,
+    maxAmountRequired:
+      ('amount' in opt ? opt.amount : opt.maxAmountRequired) ?? '0',
+    payTo: opt.payTo ?? '',
+    asset: opt.asset,
+    maxTimeoutSeconds: opt.maxTimeoutSeconds ?? 60,
+    outputSchema: outputSchemaForDb,
+    extra: undefined,
+  }));
+
+  const mappedAccepts = allMappedAccepts.filter(accept =>
+    (SUPPORTED_CHAINS as readonly string[]).includes(accept.network)
+  );
+
+  if (mappedAccepts.length === 0) {
+    const advertisedNetworks = Array.from(
+      new Set(allMappedAccepts.map(a => a.network))
     );
+    return {
+      success: false as const,
+      data: advisory.paymentRequiredBody,
+      error: {
+        type: 'parseResponse' as const,
+        parseErrors: [
+          `No supported networks advertised. Got: [${advertisedNetworks.join(', ')}]. Supported: [${(SUPPORTED_CHAINS as readonly string[]).join(', ')}]. Testnets are not indexed.`,
+        ],
+      },
+    };
+  }
 
   const x402Version = x402Options[0]?.version ?? 1;
 

apps/scan/src/lib/x402/chain-mapping.ts

@@ -0,0 +1,33 @@
+// Mirrors `ChainIdToNetwork` from the v1 `x402` SDK so the production app
+// doesn't depend on a v1 package for what is effectively a static lookup.
+// v2 uses CAIP-2 strings natively and ships no equivalent map.
+
+const EvmNetworkToChainId: Record<string, number> = {
+  abstract: 2741,
+  'abstract-testnet': 11124,
+  'base-sepolia': 84532,
+  base: 8453,
+  'avalanche-fuji': 43113,
+  avalanche: 43114,
+  iotex: 4689,
+  sei: 1329,
+  'sei-testnet': 1328,
+  polygon: 137,
+  'polygon-amoy': 80002,
+  peaq: 3338,
+  story: 1514,
+  educhain: 41923,
+  'skale-base-sepolia': 324705682,
+};
+
+const SvmNetworkToChainId: Record<string, number> = {
+  'solana-devnet': 103,
+  solana: 101,
+};
+
+export const ChainIdToNetwork: Record<number, string> = Object.fromEntries(
+  [
+    ...Object.entries(EvmNetworkToChainId),
+    ...Object.entries(SvmNetworkToChainId),
+  ].map(([network, chainId]) => [chainId, network])
+);

apps/scan/src/lib/x402/index.ts

@@ -14,7 +14,7 @@ import {
 import { x402ResponseSchemaV2, type X402ResponseV2 } from './v2';
 import type { DiscoveryExtension } from '@x402/extensions/bazaar';
 import { decodePaymentRequiredHeader } from '@x402/core/http';
-import { ChainIdToNetwork } from 'x402/types';
+import { ChainIdToNetwork } from './chain-mapping';
 import type { ParseResult } from './shared';
 
 export type OutputSchema = OutputSchemaV1;

apps/scan/src/lib/x402/v1/schema.ts

@@ -1,13 +1,26 @@
 import {
-  ChainIdToNetwork,
-  HTTPRequestStructureSchema,
-  PaymentRequirementsSchema,
-  x402ResponseSchema,
-} from 'x402/types';
+  PaymentRequiredV1Schema,
+  PaymentRequirementsV1Schema,
+} from '@x402/core/schemas';
 import { z as z3 } from 'zod3';
 
+import { ChainIdToNetwork } from '../chain-mapping';
 import { FieldDefSchema } from '../shared';
 
+// Inlined from the v1 `x402` SDK. v2 dropped the typed HTTP request structure
+// in favor of an opaque `inputSchema: Record<string, unknown>`, so there's no
+// equivalent in `@x402/*` to import.
+const HTTPRequestStructureSchema = z3.object({
+  type: z3.literal('http'),
+  method: z3.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD']),
+  queryParams: z3.record(z3.string(), z3.string()).optional(),
+  bodyType: z3
+    .enum(['json', 'form-data', 'multipart-form-data', 'text', 'binary'])
+    .optional(),
+  bodyFields: z3.record(z3.string(), z3.any()).optional(),
+  headerFields: z3.record(z3.string(), z3.any()).optional(),
+});
+
 export const outputSchemaV1 = z3.object({
   input: HTTPRequestStructureSchema.omit({
     queryParams: true,
@@ -45,21 +58,19 @@ const networkSchemaV1 = z3.union([
     .transform(v => ChainIdToNetwork[Number(v.split(':')[1])]),
 ]);
 
-export const paymentRequirementsSchemaV1 = PaymentRequirementsSchema.extend({
+export const paymentRequirementsSchemaV1 = PaymentRequirementsV1Schema.extend({
   network: networkSchemaV1,
   outputSchema: outputSchemaV1.optional(),
 });
 
-export const x402ResponseSchemaV1 = x402ResponseSchema
-  .omit({
-    error: true,
-    accepts: true,
-  })
-  .extend({
-    x402Version: z3.literal(1).default(1),
-    error: z3.string().nullish(),
-    accepts: z3.array(paymentRequirementsSchemaV1).optional(),
-  });
+export const x402ResponseSchemaV1 = PaymentRequiredV1Schema.omit({
+  error: true,
+  accepts: true,
+}).extend({
+  x402Version: z3.literal(1).default(1),
+  error: z3.string().nullish(),
+  accepts: z3.array(paymentRequirementsSchemaV1).optional(),
+});
 
 export type X402ResponseV1 = z3.infer<typeof x402ResponseSchemaV1>;
 export type OutputSchemaV1 = z3.infer<typeof outputSchemaV1>;

apps/scan/src/services/db/resources/resource.ts

@@ -7,7 +7,7 @@ import { toPaginatedResponse } from '@/lib/pagination';
 import { mixedAddressSchema, supportedChainSchema } from '@/lib/schemas';
 
 import { SUPPORTED_CHAINS } from '@/types/chain';
-import { ChainIdToNetwork } from 'x402/types';
+import { ChainIdToNetwork } from '@/lib/x402/chain-mapping';
 
 import type { PaginatedQueryParams } from '@/lib/pagination';
 import type { AcceptsNetwork, Prisma } from '@x402scan/scan-db';

apps/scan/src/services/db/resources/response.ts

@@ -1,22 +1,32 @@
 import { scanDb } from '@x402scan/scan-db';
 
+import type { Prisma } from '@x402scan/scan-db';
 import type { ParsedX402Response } from '@/lib/x402';
 
+const toPrismaJson = (
+  response: ParsedX402Response
+): Prisma.InputJsonValue => {
+  // Parsed x402 responses are JSON-safe by schema validation, but Prisma's
+  // structural JSON input type requires nested objects to have index signatures.
+  return response as unknown as Prisma.InputJsonValue;
+};
+
 export const upsertResourceResponse = async (
   resourceId: string,
   response: ParsedX402Response
 ) => {
+  const responseJson = toPrismaJson(response);
   return await scanDb.resourceResponse.upsert({
     where: {
       resourceId,
     },
     update: {
       resourceId,
-      response,
+      response: responseJson,
     },
     create: {
       resourceId,
-      response,
+      response: responseJson,
     },
   });
 };