@bankofai/x402-extensions 1.0.0-beta.0

package/dist/cjs/index.js

@@ -0,0 +1,3536 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BAZAAR: () => BAZAAR,
+  BUILDER_CODE: () => BUILDER_CODE,
+  BUILDER_CODE_PATTERN: () => BUILDER_CODE_PATTERN,
+  BUILDER_CODE_SCHEMA: () => BUILDER_CODE_SCHEMA,
+  BuilderCodeClientExtension: () => BuilderCodeClientExtension,
+  BuilderCodeFacilitatorExtension: () => BuilderCodeFacilitatorExtension,
+  EIP2612_GAS_SPONSORING: () => EIP2612_GAS_SPONSORING,
+  ERC20_APPROVAL_GAS_SPONSORING: () => ERC20_APPROVAL_GAS_SPONSORING,
+  ERC20_APPROVAL_GAS_SPONSORING_VERSION: () => ERC20_APPROVAL_GAS_SPONSORING_VERSION,
+  ERC_8021_MARKER: () => ERC_8021_MARKER,
+  InMemorySIWxStorage: () => InMemorySIWxStorage,
+  OFFER_RECEIPT: () => OFFER_RECEIPT,
+  OFFER_TYPES: () => OFFER_TYPES,
+  PAYMENT_IDENTIFIER: () => PAYMENT_IDENTIFIER,
+  PAYMENT_ID_MAX_LENGTH: () => PAYMENT_ID_MAX_LENGTH,
+  PAYMENT_ID_MIN_LENGTH: () => PAYMENT_ID_MIN_LENGTH,
+  PAYMENT_ID_PATTERN: () => PAYMENT_ID_PATTERN,
+  RECEIPT_TYPES: () => RECEIPT_TYPES,
+  SCHEMA_2_ID: () => SCHEMA_2_ID,
+  SIGN_IN_WITH_X: () => SIGN_IN_WITH_X,
+  SIWxPayloadSchema: () => SIWxPayloadSchema,
+  SOLANA_DEVNET: () => SOLANA_DEVNET,
+  SOLANA_MAINNET: () => SOLANA_MAINNET,
+  SOLANA_TESTNET: () => SOLANA_TESTNET,
+  appendPaymentIdentifierToExtensions: () => appendPaymentIdentifierToExtensions,
+  bazaarResourceServerExtension: () => bazaarResourceServerExtension,
+  buildSIWxSchema: () => buildSIWxSchema,
+  builderCodeResourceServerExtension: () => builderCodeResourceServerExtension,
+  canonicalize: () => canonicalize,
+  checkIfBazaarNeeded: () => import_server.checkIfBazaarNeeded,
+  convertNetworkStringToCAIP2: () => convertNetworkStringToCAIP2,
+  createEIP712OfferReceiptIssuer: () => createEIP712OfferReceiptIssuer,
+  createErc20ApprovalGasSponsoringExtension: () => createErc20ApprovalGasSponsoringExtension,
+  createJWS: () => createJWS,
+  createJWSOfferReceiptIssuer: () => createJWSOfferReceiptIssuer,
+  createOfferDomain: () => createOfferDomain,
+  createOfferEIP712: () => createOfferEIP712,
+  createOfferJWS: () => createOfferJWS,
+  createOfferReceiptExtension: () => createOfferReceiptExtension,
+  createReceiptDomain: () => createReceiptDomain,
+  createReceiptEIP712: () => createReceiptEIP712,
+  createReceiptJWS: () => createReceiptJWS,
+  createSIWxClientExtension: () => createSIWxClientExtension,
+  createSIWxClientHook: () => createSIWxClientHook,
+  createSIWxMessage: () => createSIWxMessage,
+  createSIWxPayload: () => createSIWxPayload,
+  createSIWxRequestHook: () => createSIWxRequestHook,
+  createSIWxResourceServerExtension: () => createSIWxResourceServerExtension,
+  createSIWxSettleHook: () => createSIWxSettleHook,
+  declareBuilderCodeExtension: () => declareBuilderCodeExtension,
+  declareDiscoveryExtension: () => declareDiscoveryExtension,
+  declareEip2612GasSponsoringExtension: () => declareEip2612GasSponsoringExtension,
+  declareErc20ApprovalGasSponsoringExtension: () => declareErc20ApprovalGasSponsoringExtension,
+  declareOfferReceiptExtension: () => declareOfferReceiptExtension,
+  declarePaymentIdentifierExtension: () => declarePaymentIdentifierExtension,
+  declareSIWxExtension: () => declareSIWxExtension,
+  decodeBase58: () => decodeBase58,
+  decodeSignedOffers: () => decodeSignedOffers,
+  encodeBase58: () => encodeBase58,
+  encodeBuilderCodeSuffix: () => encodeBuilderCodeSuffix,
+  encodeSIWxHeader: () => encodeSIWxHeader,
+  erc20ApprovalGasSponsoringSchema: () => erc20ApprovalGasSponsoringSchema,
+  extractAndValidatePaymentIdentifier: () => extractAndValidatePaymentIdentifier,
+  extractChainIdFromCAIP2: () => extractChainIdFromCAIP2,
+  extractDiscoveryInfo: () => extractDiscoveryInfo,
+  extractDiscoveryInfoFromExtension: () => extractDiscoveryInfoFromExtension,
+  extractDiscoveryInfoV1: () => extractDiscoveryInfoV1,
+  extractEIP155ChainId: () => extractEIP155ChainId,
+  extractEVMChainId: () => extractEVMChainId,
+  extractEip2612GasSponsoringInfo: () => extractEip2612GasSponsoringInfo,
+  extractErc20ApprovalGasSponsoringInfo: () => extractErc20ApprovalGasSponsoringInfo,
+  extractJWSHeader: () => extractJWSHeader,
+  extractJWSPayload: () => extractJWSPayload,
+  extractOfferPayload: () => extractOfferPayload,
+  extractOffersFromPaymentRequired: () => extractOffersFromPaymentRequired,
+  extractPaymentIdentifier: () => extractPaymentIdentifier,
+  extractPublicKeyFromKid: () => extractPublicKeyFromKid,
+  extractReceiptFromResponse: () => extractReceiptFromResponse,
+  extractReceiptPayload: () => extractReceiptPayload,
+  extractResourceMetadataV1: () => extractResourceMetadataV1,
+  extractSolanaChainReference: () => extractSolanaChainReference,
+  findAcceptsObjectFromSignedOffer: () => findAcceptsObjectFromSignedOffer,
+  formatSIWEMessage: () => formatSIWEMessage,
+  formatSIWSMessage: () => formatSIWSMessage,
+  generatePaymentId: () => generatePaymentId,
+  getCanonicalBytes: () => getCanonicalBytes,
+  getEVMAddress: () => getEVMAddress,
+  getSolanaAddress: () => getSolanaAddress,
+  hasPaymentIdentifier: () => hasPaymentIdentifier,
+  hashCanonical: () => hashCanonical,
+  hashOfferTypedData: () => hashOfferTypedData,
+  hashReceiptTypedData: () => hashReceiptTypedData,
+  isBodyExtensionConfig: () => isBodyExtensionConfig,
+  isDiscoverableV1: () => isDiscoverableV1,
+  isEIP712SignedOffer: () => isEIP712SignedOffer,
+  isEIP712SignedReceipt: () => isEIP712SignedReceipt,
+  isEIP712Signer: () => isEIP712Signer,
+  isEVMSigner: () => isEVMSigner,
+  isJWSSignedOffer: () => isJWSSignedOffer,
+  isJWSSignedReceipt: () => isJWSSignedReceipt,
+  isJWSSigner: () => isJWSSigner,
+  isMcpExtensionConfig: () => isMcpExtensionConfig,
+  isPaymentIdentifierExtension: () => isPaymentIdentifierExtension,
+  isPaymentIdentifierRequired: () => isPaymentIdentifierRequired,
+  isQueryExtensionConfig: () => isQueryExtensionConfig,
+  isSolanaSigner: () => isSolanaSigner,
+  isValidIconUrl: () => isValidIconUrl,
+  isValidPaymentId: () => isValidPaymentId,
+  isValidRouteTemplate: () => isValidRouteTemplate,
+  isValidServiceName: () => isValidServiceName,
+  parseBuilderCodeSuffixFromCalldata: () => parseBuilderCodeSuffixFromCalldata,
+  parseSIWxHeader: () => parseSIWxHeader,
+  paymentIdentifierResourceServerExtension: () => paymentIdentifierResourceServerExtension,
+  paymentIdentifierSchema: () => paymentIdentifierSchema,
+  prepareOfferForEIP712: () => prepareOfferForEIP712,
+  prepareReceiptForEIP712: () => prepareReceiptForEIP712,
+  sanitizeResourceServiceMetadata: () => sanitizeResourceServiceMetadata,
+  sanitizeTags: () => sanitizeTags,
+  signEVMMessage: () => signEVMMessage,
+  signOfferEIP712: () => signOfferEIP712,
+  signReceiptEIP712: () => signReceiptEIP712,
+  signSolanaMessage: () => signSolanaMessage,
+  validateAndExtract: () => validateAndExtract,
+  validateBazaarRouteExtensions: () => validateBazaarRouteExtensions,
+  validateDiscoveryExtension: () => validateDiscoveryExtension,
+  validateDiscoveryExtensionSpec: () => validateDiscoveryExtensionSpec,
+  validateEip2612GasSponsoringInfo: () => validateEip2612GasSponsoringInfo,
+  validateErc20ApprovalGasSponsoringInfo: () => validateErc20ApprovalGasSponsoringInfo,
+  validatePaymentIdentifier: () => validatePaymentIdentifier,
+  validatePaymentIdentifierRequirement: () => validatePaymentIdentifierRequirement,
+  validateRouteTemplate: () => validateRouteTemplate,
+  validateSIWxMessage: () => validateSIWxMessage,
+  verifyEVMSignature: () => verifyEVMSignature,
+  verifyOfferSignatureEIP712: () => verifyOfferSignatureEIP712,
+  verifyOfferSignatureJWS: () => verifyOfferSignatureJWS,
+  verifyReceiptMatchesOffer: () => verifyReceiptMatchesOffer,
+  verifyReceiptSignatureEIP712: () => verifyReceiptSignatureEIP712,
+  verifyReceiptSignatureJWS: () => verifyReceiptSignatureJWS,
+  verifySIWxSignature: () => verifySIWxSignature,
+  verifySolanaSignature: () => verifySolanaSignature,
+  withBazaar: () => withBazaar,
+  wrapFetchWithSIWx: () => wrapFetchWithSIWx
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/bazaar/http/types.ts
+var isQueryExtensionConfig = (config) => {
+  return !("bodyType" in config) && !("toolName" in config);
+};
+var isBodyExtensionConfig = (config) => {
+  return "bodyType" in config;
+};
+
+// src/bazaar/mcp/types.ts
+var isMcpExtensionConfig = (config) => {
+  return "toolName" in config;
+};
+
+// src/bazaar/types.ts
+var BAZAAR = { key: "bazaar" };
+
+// src/bazaar/http/resourceService.ts
+function createQueryDiscoveryExtension({
+  method,
+  input = {},
+  inputSchema = { properties: {} },
+  pathParams,
+  pathParamsSchema,
+  output
+}) {
+  return {
+    info: {
+      input: {
+        type: "http",
+        ...method ? { method } : {},
+        ...input ? { queryParams: input } : {},
+        ...pathParams ? { pathParams } : {}
+      },
+      ...output?.example ? {
+        output: {
+          type: "json",
+          example: output.example
+        }
+      } : {}
+    },
+    schema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties: {
+        input: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "http"
+            },
+            method: {
+              type: "string",
+              enum: ["GET", "HEAD", "DELETE"]
+            },
+            ...inputSchema ? {
+              queryParams: {
+                type: "object",
+                ...typeof inputSchema === "object" ? inputSchema : {}
+              }
+            } : {},
+            ...pathParamsSchema ? {
+              pathParams: {
+                type: "object",
+                ...typeof pathParamsSchema === "object" ? pathParamsSchema : {}
+              }
+            } : {}
+          },
+          required: ["type", "method"],
+          // pathParams are not declared here at schema build time --
+          // the server extension's enrichDeclaration adds them to both info and schema
+          // atomically at request time, keeping data and schema consistent.
+          additionalProperties: false
+        },
+        ...output?.example ? {
+          output: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string"
+              },
+              example: {
+                type: "object",
+                ...output.schema && typeof output.schema === "object" ? output.schema : {}
+              }
+            },
+            required: ["type"]
+          }
+        } : {}
+      },
+      required: ["input"]
+    }
+  };
+}
+function createBodyDiscoveryExtension({
+  method,
+  input = {},
+  inputSchema = { properties: {} },
+  pathParams,
+  pathParamsSchema,
+  bodyType,
+  output
+}) {
+  return {
+    info: {
+      input: {
+        type: "http",
+        ...method ? { method } : {},
+        bodyType,
+        body: input,
+        ...pathParams ? { pathParams } : {}
+      },
+      ...output?.example ? {
+        output: {
+          type: "json",
+          example: output.example
+        }
+      } : {}
+    },
+    schema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties: {
+        input: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "http"
+            },
+            method: {
+              type: "string",
+              enum: ["POST", "PUT", "PATCH"]
+            },
+            bodyType: {
+              type: "string",
+              enum: ["json", "form-data", "text"]
+            },
+            body: inputSchema,
+            ...pathParamsSchema ? {
+              pathParams: {
+                type: "object",
+                ...typeof pathParamsSchema === "object" ? pathParamsSchema : {}
+              }
+            } : {}
+          },
+          required: ["type", "method", "bodyType", "body"],
+          // pathParams are not declared here at schema build time --
+          // the server extension's enrichDeclaration adds them to both info and schema
+          // atomically at request time, keeping data and schema consistent.
+          additionalProperties: false
+        },
+        ...output?.example ? {
+          output: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string"
+              },
+              example: {
+                type: "object",
+                ...output.schema && typeof output.schema === "object" ? output.schema : {}
+              }
+            },
+            required: ["type"]
+          }
+        } : {}
+      },
+      required: ["input"]
+    }
+  };
+}
+
+// src/bazaar/mcp/resourceService.ts
+function createMcpDiscoveryExtension({
+  toolName,
+  description,
+  transport,
+  inputSchema,
+  example,
+  output
+}) {
+  return {
+    info: {
+      input: {
+        type: "mcp",
+        toolName,
+        ...description !== void 0 ? { description } : {},
+        ...transport !== void 0 ? { transport } : {},
+        inputSchema,
+        ...example !== void 0 ? { example } : {}
+      },
+      ...output?.example ? {
+        output: {
+          type: "json",
+          example: output.example
+        }
+      } : {}
+    },
+    schema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties: {
+        input: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "mcp"
+            },
+            toolName: {
+              type: "string"
+            },
+            ...description !== void 0 ? {
+              description: {
+                type: "string"
+              }
+            } : {},
+            ...transport !== void 0 ? {
+              transport: {
+                type: "string",
+                ...transport === "streamable-http" || transport === "sse" ? { enum: [transport] } : {}
+              }
+            } : {},
+            inputSchema: {
+              type: "object"
+            },
+            ...example !== void 0 ? {
+              example: {
+                type: "object"
+              }
+            } : {}
+          },
+          required: ["type", "toolName", "inputSchema"],
+          additionalProperties: false
+        },
+        ...output?.example ? {
+          output: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string"
+              },
+              example: {
+                type: "object",
+                ...output.schema && typeof output.schema === "object" ? output.schema : {}
+              }
+            },
+            required: ["type"]
+          }
+        } : {}
+      },
+      required: ["input"]
+    }
+  };
+}
+
+// src/bazaar/resourceService.ts
+function declareDiscoveryExtension(config) {
+  if ("toolName" in config) {
+    const extension2 = createMcpDiscoveryExtension(config);
+    return { bazaar: extension2 };
+  }
+  const bodyType = config.bodyType;
+  const isBodyMethod2 = bodyType !== void 0;
+  const extension = isBodyMethod2 ? createBodyDiscoveryExtension(config) : createQueryDiscoveryExtension(config);
+  return { bazaar: extension };
+}
+
+// src/bazaar/server.ts
+var BRACKET_PARAM_REGEX = /\[([^\]]+)\]/;
+var BRACKET_PARAM_REGEX_ALL = /\[([^\]]+)\]/g;
+var COLON_PARAM_REGEX = /:([a-zA-Z_][a-zA-Z0-9_]*)/;
+function isHTTPRequestContext(ctx) {
+  return ctx !== null && typeof ctx === "object" && "method" in ctx && "adapter" in ctx;
+}
+function normalizeWildcardPattern(pattern) {
+  if (!pattern.includes("*")) {
+    return pattern;
+  }
+  let counter = 0;
+  return pattern.split("/").map((seg) => {
+    if (seg === "*") {
+      counter++;
+      return `:var${counter}`;
+    }
+    return seg;
+  }).join("/");
+}
+function extractDynamicRouteInfo(routePattern, urlPath) {
+  const hasBracket = BRACKET_PARAM_REGEX.test(routePattern);
+  const hasColon = COLON_PARAM_REGEX.test(routePattern);
+  if (!hasBracket && !hasColon) {
+    return null;
+  }
+  const normalizedPattern = hasBracket ? routePattern.replace(BRACKET_PARAM_REGEX_ALL, ":$1") : routePattern;
+  const pathParams = extractPathParams(normalizedPattern, urlPath, false);
+  return { routeTemplate: normalizedPattern, pathParams };
+}
+function extractPathParams(routePattern, urlPath, isBracket) {
+  const paramNames = [];
+  const splitRegex = isBracket ? BRACKET_PARAM_REGEX : COLON_PARAM_REGEX;
+  const parts = routePattern.split(splitRegex);
+  const regexParts = [];
+  parts.forEach((part, i) => {
+    if (i % 2 === 0) {
+      regexParts.push(part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    } else {
+      paramNames.push(part);
+      regexParts.push("([^/]+)");
+    }
+  });
+  const regex = new RegExp(`^${regexParts.join("")}$`);
+  const match = urlPath.match(regex);
+  if (!match) return {};
+  const result = {};
+  paramNames.forEach((name, idx) => {
+    result[name] = match[idx + 1];
+  });
+  return result;
+}
+var bazaarResourceServerExtension = {
+  key: BAZAAR.key,
+  enrichDeclaration: (declaration, transportContext) => {
+    if (!isHTTPRequestContext(transportContext)) {
+      return declaration;
+    }
+    const extension = declaration;
+    if (extension.info?.input?.type === "mcp") {
+      return declaration;
+    }
+    const method = transportContext.method;
+    const existingInputProps = extension.schema?.properties?.input?.properties || {};
+    const updatedInputProps = {
+      ...existingInputProps,
+      method: {
+        type: "string",
+        enum: [method]
+      }
+    };
+    const enrichedResult = {
+      ...extension,
+      info: {
+        ...extension.info || {},
+        input: {
+          ...extension.info?.input || {},
+          method
+        }
+      },
+      schema: {
+        ...extension.schema || {},
+        properties: {
+          ...extension.schema?.properties || {},
+          input: {
+            ...extension.schema?.properties?.input || {},
+            properties: updatedInputProps,
+            required: [
+              ...extension.schema?.properties?.input?.required || [],
+              ...!(extension.schema?.properties?.input?.required || []).includes("method") ? ["method"] : []
+            ]
+          }
+        }
+      }
+    };
+    const rawRoutePattern = transportContext.routePattern;
+    const routePattern = rawRoutePattern ? normalizeWildcardPattern(rawRoutePattern) : void 0;
+    const dynamicRoute = routePattern ? extractDynamicRouteInfo(routePattern, transportContext.adapter.getPath()) : null;
+    if (dynamicRoute) {
+      const inputSchemaProps = enrichedResult.schema?.properties?.input?.properties || {};
+      const hasPathParamsInSchema = "pathParams" in inputSchemaProps;
+      return {
+        ...enrichedResult,
+        routeTemplate: dynamicRoute.routeTemplate,
+        info: {
+          ...enrichedResult.info,
+          input: { ...enrichedResult.info.input, pathParams: dynamicRoute.pathParams }
+        },
+        ...!hasPathParamsInSchema ? {
+          schema: {
+            ...enrichedResult.schema,
+            properties: {
+              ...enrichedResult.schema?.properties,
+              input: {
+                ...enrichedResult.schema?.properties?.input,
+                properties: {
+                  ...inputSchemaProps,
+                  pathParams: { type: "object" }
+                }
+              }
+            }
+          }
+        } : {}
+      };
+    }
+    return enrichedResult;
+  }
+};
+
+// src/bazaar/facilitator.ts
+var import_node_url = require("url");
+var import__ = __toESM(require("ajv/dist/2020.js"));
+
+// src/bazaar/v1/facilitator.ts
+function hasV1OutputSchema(obj) {
+  return obj !== null && typeof obj === "object" && "input" in obj && obj.input !== null && typeof obj.input === "object" && "type" in obj.input && obj.input.type === "http" && "method" in obj.input;
+}
+function isQueryMethod(method) {
+  const upperMethod = method.toUpperCase();
+  return upperMethod === "GET" || upperMethod === "HEAD" || upperMethod === "DELETE";
+}
+function isBodyMethod(method) {
+  const upperMethod = method.toUpperCase();
+  return upperMethod === "POST" || upperMethod === "PUT" || upperMethod === "PATCH";
+}
+function extractQueryParams(v1Input) {
+  if (v1Input.queryParams && typeof v1Input.queryParams === "object") {
+    return v1Input.queryParams;
+  }
+  if (v1Input.query_params && typeof v1Input.query_params === "object") {
+    return v1Input.query_params;
+  }
+  if (v1Input.query && typeof v1Input.query === "object") {
+    return v1Input.query;
+  }
+  if (v1Input.params && typeof v1Input.params === "object") {
+    return v1Input.params;
+  }
+  return void 0;
+}
+function extractBodyInfo(v1Input) {
+  let bodyType = "json";
+  const bodyTypeField = v1Input.bodyType || v1Input.body_type;
+  if (bodyTypeField && typeof bodyTypeField === "string") {
+    const type = bodyTypeField.toLowerCase();
+    if (type.includes("form") || type.includes("multipart")) {
+      bodyType = "form-data";
+    } else if (type.includes("text") || type.includes("plain")) {
+      bodyType = "text";
+    } else {
+      bodyType = "json";
+    }
+  }
+  let body = {};
+  if (v1Input.bodyFields && typeof v1Input.bodyFields === "object") {
+    body = v1Input.bodyFields;
+  } else if (v1Input.body_fields && v1Input.body_fields !== null && typeof v1Input.body_fields === "object") {
+    body = v1Input.body_fields;
+  } else if (v1Input.bodyParams && typeof v1Input.bodyParams === "object") {
+    body = v1Input.bodyParams;
+  } else if (v1Input.body && typeof v1Input.body === "object") {
+    body = v1Input.body;
+  } else if (v1Input.data && typeof v1Input.data === "object") {
+    body = v1Input.data;
+  } else if (v1Input.properties && typeof v1Input.properties === "object") {
+    body = v1Input.properties;
+  }
+  return { body, bodyType };
+}
+function extractDiscoveryInfoV1(paymentRequirements) {
+  const { outputSchema } = paymentRequirements;
+  if (!outputSchema || !hasV1OutputSchema(outputSchema)) {
+    return null;
+  }
+  const v1Input = outputSchema.input;
+  const isDiscoverable = v1Input.discoverable ?? true;
+  if (!isDiscoverable) {
+    return null;
+  }
+  const method = typeof v1Input.method === "string" ? v1Input.method.toUpperCase() : "";
+  const headersRaw = v1Input.headerFields || v1Input.header_fields || v1Input.headers;
+  const headers = headersRaw && typeof headersRaw === "object" ? headersRaw : void 0;
+  const output = outputSchema.output ? {
+    type: "json",
+    example: outputSchema.output
+  } : void 0;
+  if (isQueryMethod(method)) {
+    const queryParams = extractQueryParams(v1Input);
+    const discoveryInfo = {
+      input: {
+        type: "http",
+        method,
+        ...queryParams ? { queryParams } : {},
+        ...headers ? { headers } : {}
+      },
+      ...output ? { output } : {}
+    };
+    return discoveryInfo;
+  } else if (isBodyMethod(method)) {
+    const { body, bodyType } = extractBodyInfo(v1Input);
+    const queryParams = extractQueryParams(v1Input);
+    const discoveryInfo = {
+      input: {
+        type: "http",
+        method,
+        bodyType,
+        body,
+        ...queryParams ? { queryParams } : {},
+        ...headers ? { headers } : {}
+      },
+      ...output ? { output } : {}
+    };
+    return discoveryInfo;
+  }
+  return null;
+}
+function isDiscoverableV1(paymentRequirements) {
+  return extractDiscoveryInfoV1(paymentRequirements) !== null;
+}
+function extractResourceMetadataV1(paymentRequirements) {
+  return {
+    url: paymentRequirements.resource,
+    description: paymentRequirements.description,
+    mimeType: paymentRequirements.mimeType
+  };
+}
+function buildBazaarExtensionFromDiscoveryInfo(discoveryInfo) {
+  return {
+    info: discoveryInfo,
+    schema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties: {
+        input: { type: "object" },
+        output: { type: "object" }
+      },
+      required: ["input"]
+    }
+  };
+}
+function buildV1CatalogExtensions(existingExtensions, discoveryInfo) {
+  if (existingExtensions?.[BAZAAR.key]) {
+    return existingExtensions;
+  }
+  const extensions = existingExtensions ? { ...existingExtensions } : {};
+  delete extensions.outputSchema;
+  extensions[BAZAAR.key] = buildBazaarExtensionFromDiscoveryInfo(discoveryInfo);
+  return extensions;
+}
+
+// src/bazaar/facilitator.ts
+var ROUTE_TEMPLATE_REGEX = /^\/[a-zA-Z0-9_/:.\-~%]+$/;
+function isValidRouteTemplate(value) {
+  if (!value) return false;
+  if (!ROUTE_TEMPLATE_REGEX.test(value)) return false;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    return false;
+  }
+  if (decoded.includes("..")) return false;
+  if (decoded.includes("://")) return false;
+  return true;
+}
+function validateRouteTemplate(value) {
+  return isValidRouteTemplate(value) ? value : void 0;
+}
+var MAX_SERVICE_NAME_LEN = 32;
+var MAX_TAG_LEN = 32;
+var MAX_TAGS = 5;
+var MAX_ICON_URL_LEN = 2048;
+var CONTROL_CHAR_REGEX = /[\x00-\x1f\x7f]/;
+var PRINTABLE_ASCII_REGEX = /^[\x20-\x7e]+$/;
+var UNICODE_CONTROL_REGEX = /\p{Cc}/u;
+var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set([
+  "localhost",
+  "localhost.localdomain",
+  "ip6-localhost",
+  "ip6-loopback"
+]);
+var IPV4_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+var ALL_DIGITS_REGEX = /^\d+$/;
+var HEX_LITERAL_REGEX = /^0x[0-9a-f]+$/i;
+function isValidServiceName(value) {
+  if (typeof value !== "string") return false;
+  if (value.length === 0 || value.length > MAX_SERVICE_NAME_LEN) return false;
+  if (UNICODE_CONTROL_REGEX.test(value)) return false;
+  if (!PRINTABLE_ASCII_REGEX.test(value)) return false;
+  return true;
+}
+function sanitizeTags(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "string") continue;
+    if (entry.length === 0 || entry.length > MAX_TAG_LEN) continue;
+    if (UNICODE_CONTROL_REGEX.test(entry)) continue;
+    if (!PRINTABLE_ASCII_REGEX.test(entry)) continue;
+    const key = entry.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(entry);
+    if (out.length === MAX_TAGS) break;
+  }
+  return out.length > 0 ? out : void 0;
+}
+function isValidIconUrl(value) {
+  if (typeof value !== "string") return false;
+  if (value.length === 0 || value.length > MAX_ICON_URL_LEN) return false;
+  if (CONTROL_CHAR_REGEX.test(value)) return false;
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+  if (parsed.username !== "" || parsed.password !== "") return false;
+  if (parsed.host.startsWith("[")) return false;
+  let hostname;
+  try {
+    hostname = decodeURIComponent(parsed.hostname);
+  } catch {
+    return false;
+  }
+  const asciiHost = (0, import_node_url.domainToASCII)(hostname);
+  if (asciiHost === "") return false;
+  hostname = asciiHost.toLowerCase();
+  if (hostname === "") return false;
+  if (LOOPBACK_HOSTNAMES.has(hostname)) return false;
+  if (IPV4_REGEX.test(hostname)) return false;
+  if (ALL_DIGITS_REGEX.test(hostname)) return false;
+  if (HEX_LITERAL_REGEX.test(hostname)) return false;
+  return true;
+}
+function sanitizeResourceServiceMetadata(resource) {
+  if (!resource) return {};
+  const out = {};
+  if (isValidServiceName(resource.serviceName)) {
+    out.serviceName = resource.serviceName;
+  }
+  const tags = sanitizeTags(resource.tags);
+  if (tags) {
+    out.tags = tags;
+  }
+  if (isValidIconUrl(resource.iconUrl)) {
+    out.iconUrl = resource.iconUrl;
+  }
+  return out;
+}
+function validateDiscoveryExtension(extension) {
+  try {
+    const ajv = new import__.default({ strict: false, allErrors: true });
+    const validate = ajv.compile(extension.schema);
+    const valid = validate(extension.info);
+    if (valid) {
+      return { valid: true };
+    }
+    const errors = validate.errors?.map((err) => {
+      const path = err.instancePath || "(root)";
+      return `${path}: ${err.message}`;
+    }) || ["Unknown validation error"];
+    return { valid: false, errors };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        `Schema validation failed: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+}
+var VALID_QUERY_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "DELETE"]);
+var VALID_BODY_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var VALID_METHODS = /* @__PURE__ */ new Set([...VALID_QUERY_METHODS, ...VALID_BODY_METHODS]);
+var VALID_BODY_TYPES = /* @__PURE__ */ new Set(["json", "form-data", "text"]);
+var VALID_MCP_TRANSPORTS = /* @__PURE__ */ new Set(["streamable-http", "sse"]);
+function validateDiscoveryExtensionSpec(extension) {
+  const errors = [];
+  const info = extension.info;
+  if (!info || typeof info !== "object") {
+    return { valid: false, errors: ["Missing or invalid 'info' field"] };
+  }
+  const input = info.input;
+  if (!input || typeof input !== "object") {
+    return { valid: false, errors: ["Missing or invalid 'info.input' field"] };
+  }
+  const inputObj = input;
+  const inputType = inputObj.type;
+  if (inputType !== "http" && inputType !== "mcp") {
+    errors.push(`info.input.type must be "http" or "mcp", got "${String(inputType)}"`);
+    return { valid: false, errors };
+  }
+  if (inputType === "http") {
+    const method = inputObj.method;
+    if (method !== void 0 && !VALID_METHODS.has(method)) {
+      errors.push(
+        `info.input.method must be one of ${[...VALID_METHODS].join(", ")}, got "${String(method)}"`
+      );
+    }
+    const bodyType = inputObj.bodyType;
+    if (bodyType !== void 0) {
+      if (!VALID_BODY_TYPES.has(bodyType)) {
+        errors.push(
+          `info.input.bodyType must be one of ${[...VALID_BODY_TYPES].join(", ")}, got "${String(bodyType)}"`
+        );
+      }
+      if (method !== void 0 && !VALID_BODY_METHODS.has(method)) {
+        errors.push(
+          `info.input.bodyType is set but method "${String(method)}" is not a body method (POST, PUT, PATCH)`
+        );
+      }
+    }
+  }
+  if (inputType === "mcp") {
+    if (typeof inputObj.toolName !== "string" || inputObj.toolName.length === 0) {
+      errors.push(
+        "info.input.toolName is required and must be a non-empty string for MCP extensions"
+      );
+    }
+    if (!inputObj.inputSchema || typeof inputObj.inputSchema !== "object") {
+      errors.push("info.input.inputSchema is required and must be an object for MCP extensions");
+    }
+    const transport = inputObj.transport;
+    if (transport !== void 0 && !VALID_MCP_TRANSPORTS.has(transport)) {
+      errors.push(
+        `info.input.transport must be one of ${[...VALID_MCP_TRANSPORTS].join(", ")}, got "${String(transport)}"`
+      );
+    }
+  }
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}
+function extractDiscoveryInfo(paymentPayload, paymentRequirements, validate = true) {
+  let discoveryInfo = null;
+  let resourceUrl;
+  let routeTemplate;
+  if (paymentPayload.x402Version === 2) {
+    resourceUrl = paymentPayload.resource?.url ?? "";
+    if (paymentPayload.extensions) {
+      const bazaarExtension = paymentPayload.extensions[BAZAAR.key];
+      if (bazaarExtension && typeof bazaarExtension === "object") {
+        try {
+          const rawExt = bazaarExtension;
+          const rawTemplate = typeof rawExt.routeTemplate === "string" ? rawExt.routeTemplate : void 0;
+          if (isValidRouteTemplate(rawTemplate)) {
+            routeTemplate = rawTemplate;
+          }
+          const extension = bazaarExtension;
+          if (validate) {
+            const result = validateDiscoveryExtension(extension);
+            if (!result.valid) {
+              console.warn(
+                `V2 discovery extension validation failed: ${result.errors?.join(", ")}`
+              );
+            } else {
+              discoveryInfo = extension.info;
+            }
+          } else {
+            discoveryInfo = extension.info;
+          }
+        } catch (error) {
+          console.warn(`V2 discovery extension extraction failed: ${error}`);
+        }
+      }
+    }
+  } else if (paymentPayload.x402Version === 1) {
+    const requirementsV1 = paymentRequirements;
+    resourceUrl = requirementsV1.resource;
+    discoveryInfo = extractDiscoveryInfoV1(requirementsV1);
+  } else {
+    return null;
+  }
+  if (!discoveryInfo) {
+    return null;
+  }
+  const url = new URL(resourceUrl);
+  const canonicalUrl = routeTemplate ? `${url.origin}${routeTemplate}` : `${url.origin}${url.pathname}`;
+  let description;
+  let mimeType;
+  let serviceMetadata = {};
+  if (paymentPayload.x402Version === 2) {
+    description = paymentPayload.resource?.description;
+    mimeType = paymentPayload.resource?.mimeType;
+    serviceMetadata = sanitizeResourceServiceMetadata(paymentPayload.resource);
+  } else if (paymentPayload.x402Version === 1) {
+    const requirementsV1 = paymentRequirements;
+    description = requirementsV1.description;
+    mimeType = requirementsV1.mimeType;
+  }
+  let extensions;
+  if (paymentPayload.x402Version === 2) {
+    extensions = paymentPayload.extensions;
+  } else if (paymentPayload.x402Version === 1) {
+    extensions = buildV1CatalogExtensions(paymentPayload.extensions, discoveryInfo);
+  }
+  const base = {
+    resourceUrl: canonicalUrl,
+    description,
+    mimeType,
+    ...serviceMetadata,
+    x402Version: paymentPayload.x402Version,
+    discoveryInfo,
+    extensions
+  };
+  if (discoveryInfo.input.type === "mcp") {
+    return { ...base, toolName: discoveryInfo.input.toolName };
+  }
+  return { ...base, routeTemplate, method: discoveryInfo.input.method };
+}
+function extractDiscoveryInfoFromExtension(extension, validate = true) {
+  if (validate) {
+    const result = validateDiscoveryExtension(extension);
+    if (!result.valid) {
+      throw new Error(
+        `Invalid discovery extension: ${result.errors?.join(", ") || "Unknown error"}`
+      );
+    }
+  }
+  return extension.info;
+}
+function validateAndExtract(extension) {
+  const result = validateDiscoveryExtension(extension);
+  if (result.valid) {
+    return {
+      valid: true,
+      info: extension.info
+    };
+  }
+  return {
+    valid: false,
+    errors: result.errors
+  };
+}
+
+// src/bazaar/startupValidation.ts
+var import_server = require("@bankofai/x402-core/server");
+var HTTP_VERB_RE = /^(GET|POST|PUT|PATCH|DELETE|HEAD)\b/i;
+function withSyntheticMethod(ext, pattern) {
+  const info = ext.info;
+  const input = info?.input;
+  if (!input || typeof input.method === "string" && input.method) {
+    return ext;
+  }
+  const verbMatch = pattern.match(HTTP_VERB_RE);
+  const method = verbMatch ? verbMatch[1].toUpperCase() : input.body !== void 0 || input.bodyType !== void 0 ? "POST" : "GET";
+  return { ...ext, info: { ...info, input: { ...input, method } } };
+}
+function validateBazaarRouteExtensions(routes) {
+  const entries = "accepts" in routes ? [["*", routes]] : Object.entries(routes);
+  for (const [pattern, config] of entries) {
+    const bazaarExt = config.extensions?.["bazaar"];
+    if (!bazaarExt) continue;
+    if (typeof bazaarExt === "object" && bazaarExt !== null && "info" in bazaarExt && "schema" in bazaarExt) {
+      const specResult = validateDiscoveryExtensionSpec(bazaarExt);
+      if (!specResult.valid) {
+        console.warn(
+          `x402: Route "${pattern}" has an invalid bazaar extension: ${specResult.errors?.join(", ")}`
+        );
+        continue;
+      }
+      const extForSchema = withSyntheticMethod(bazaarExt, pattern);
+      const schemaResult = validateDiscoveryExtension(
+        extForSchema
+      );
+      if (!schemaResult.valid) {
+        console.warn(
+          `x402: Route "${pattern}" has an invalid bazaar extension: ${schemaResult.errors?.join(", ")}`
+        );
+      }
+    } else {
+      console.warn(
+        `x402: Route "${pattern}" declares a bazaar extension but it is malformed (expected an object with "info" and "schema" fields)`
+      );
+    }
+  }
+}
+
+// src/bazaar/facilitatorClient.ts
+function withBazaar(client) {
+  const existingExtensions = client.extensions ?? {};
+  const extended = client;
+  extended.extensions = {
+    ...existingExtensions,
+    bazaar: {
+      async listResources(params) {
+        let headers = {
+          "Content-Type": "application/json"
+        };
+        const authHeaders = await client.createAuthHeaders("bazaar");
+        headers = { ...headers, ...authHeaders.headers };
+        const queryParams = new URLSearchParams();
+        if (params?.type !== void 0) {
+          queryParams.set("type", params.type);
+        }
+        if (params?.payTo !== void 0) {
+          queryParams.set("payTo", params.payTo);
+        }
+        if (params?.scheme !== void 0) {
+          queryParams.set("scheme", params.scheme);
+        }
+        if (params?.network !== void 0) {
+          queryParams.set("network", params.network);
+        }
+        if (params?.extensions !== void 0) {
+          queryParams.set("extensions", params.extensions);
+        }
+        if (params?.limit !== void 0) {
+          queryParams.set("limit", params.limit.toString());
+        }
+        if (params?.offset !== void 0) {
+          queryParams.set("offset", params.offset.toString());
+        }
+        const queryString = queryParams.toString();
+        const endpoint = `${client.url}/discovery/resources${queryString ? `?${queryString}` : ""}`;
+        const response = await fetch(endpoint, {
+          method: "GET",
+          headers
+        });
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => response.statusText);
+          throw new Error(
+            `Facilitator listDiscoveryResources failed (${response.status}): ${errorText}`
+          );
+        }
+        return await response.json();
+      },
+      async search(params) {
+        let headers = {
+          "Content-Type": "application/json"
+        };
+        const authHeaders = await client.createAuthHeaders("bazaar");
+        headers = { ...headers, ...authHeaders.headers };
+        const queryParams = new URLSearchParams();
+        queryParams.set("query", params.query);
+        if (params.type !== void 0) {
+          queryParams.set("type", params.type);
+        }
+        if (params.payTo !== void 0) {
+          queryParams.set("payTo", params.payTo);
+        }
+        if (params.scheme !== void 0) {
+          queryParams.set("scheme", params.scheme);
+        }
+        if (params.network !== void 0) {
+          queryParams.set("network", params.network);
+        }
+        if (params.extensions !== void 0) {
+          queryParams.set("extensions", params.extensions);
+        }
+        if (params.limit !== void 0) {
+          queryParams.set("limit", params.limit.toString());
+        }
+        if (params.cursor !== void 0) {
+          queryParams.set("cursor", params.cursor);
+        }
+        const endpoint = `${client.url}/discovery/search?${queryParams.toString()}`;
+        const response = await fetch(endpoint, {
+          method: "GET",
+          headers
+        });
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => response.statusText);
+          throw new Error(
+            `Facilitator searchDiscoveryResources failed (${response.status}): ${errorText}`
+          );
+        }
+        return await response.json();
+      }
+    }
+  };
+  return extended;
+}
+
+// src/sign-in-with-x/types.ts
+var import_zod = require("zod");
+var SIGN_IN_WITH_X = "sign-in-with-x";
+var SIWxPayloadSchema = import_zod.z.object({
+  domain: import_zod.z.string(),
+  address: import_zod.z.string(),
+  statement: import_zod.z.string().optional(),
+  uri: import_zod.z.string(),
+  version: import_zod.z.string(),
+  chainId: import_zod.z.string(),
+  type: import_zod.z.enum(["eip191", "ed25519"]),
+  nonce: import_zod.z.string(),
+  issuedAt: import_zod.z.string(),
+  expirationTime: import_zod.z.string().optional(),
+  notBefore: import_zod.z.string().optional(),
+  requestId: import_zod.z.string().optional(),
+  resources: import_zod.z.array(import_zod.z.string()).optional(),
+  signatureScheme: import_zod.z.enum(["eip191", "eip1271", "eip6492", "siws"]).optional(),
+  signature: import_zod.z.string()
+});
+
+// src/sign-in-with-x/solana.ts
+var import_base = require("@scure/base");
+var import_tweetnacl = __toESM(require("tweetnacl"));
+var SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var SOLANA_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+var SOLANA_TESTNET = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+function extractSolanaChainReference(chainId) {
+  const [, reference] = chainId.split(":");
+  return reference;
+}
+function formatSIWSMessage(info, address) {
+  const lines = [
+    `${info.domain} wants you to sign in with your Solana account:`,
+    address,
+    ""
+  ];
+  if (info.statement) {
+    lines.push(info.statement, "");
+  }
+  lines.push(
+    `URI: ${info.uri}`,
+    `Version: ${info.version}`,
+    `Chain ID: ${extractSolanaChainReference(info.chainId)}`,
+    `Nonce: ${info.nonce}`,
+    `Issued At: ${info.issuedAt}`
+  );
+  if (info.expirationTime) {
+    lines.push(`Expiration Time: ${info.expirationTime}`);
+  }
+  if (info.notBefore) {
+    lines.push(`Not Before: ${info.notBefore}`);
+  }
+  if (info.requestId) {
+    lines.push(`Request ID: ${info.requestId}`);
+  }
+  if (info.resources && info.resources.length > 0) {
+    lines.push("Resources:");
+    for (const resource of info.resources) {
+      lines.push(`- ${resource}`);
+    }
+  }
+  return lines.join("\n");
+}
+function verifySolanaSignature(message, signature, publicKey) {
+  const messageBytes = new TextEncoder().encode(message);
+  return import_tweetnacl.default.sign.detached.verify(messageBytes, signature, publicKey);
+}
+function decodeBase58(encoded) {
+  return import_base.base58.decode(encoded);
+}
+function encodeBase58(bytes) {
+  return import_base.base58.encode(bytes);
+}
+function isSolanaSigner(signer) {
+  if ("signMessages" in signer && typeof signer.signMessages === "function") {
+    return true;
+  }
+  if ("publicKey" in signer && signer.publicKey) {
+    const pk = signer.publicKey;
+    if (typeof pk === "object" && pk !== null && "toBase58" in pk) {
+      return true;
+    }
+    if (typeof pk === "string" && !pk.startsWith("0x")) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/sign-in-with-x/schema.ts
+function buildSIWxSchema() {
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties: {
+      domain: { type: "string" },
+      address: { type: "string" },
+      statement: { type: "string" },
+      uri: { type: "string", format: "uri" },
+      version: { type: "string" },
+      chainId: { type: "string" },
+      type: { type: "string" },
+      nonce: { type: "string" },
+      issuedAt: { type: "string", format: "date-time" },
+      expirationTime: { type: "string", format: "date-time" },
+      notBefore: { type: "string", format: "date-time" },
+      requestId: { type: "string" },
+      resources: { type: "array", items: { type: "string", format: "uri" } },
+      signature: { type: "string" }
+    },
+    required: [
+      "domain",
+      "address",
+      "uri",
+      "version",
+      "chainId",
+      "type",
+      "nonce",
+      "issuedAt",
+      "signature"
+    ]
+  };
+}
+
+// src/sign-in-with-x/declare.ts
+function getSignatureType(network) {
+  return network.startsWith("solana:") ? "ed25519" : "eip191";
+}
+function declareSIWxExtension(options = {}) {
+  const info = {
+    version: options.version ?? "1"
+  };
+  if (options.domain) {
+    info.domain = options.domain;
+  }
+  if (options.resourceUri) {
+    info.uri = options.resourceUri;
+    info.resources = [options.resourceUri];
+  }
+  if (options.statement) {
+    info.statement = options.statement;
+  }
+  let supportedChains = [];
+  if (options.network) {
+    const networks = Array.isArray(options.network) ? options.network : [options.network];
+    supportedChains = networks.map((network) => ({
+      chainId: network,
+      type: getSignatureType(network)
+    }));
+  }
+  const declaration = {
+    info,
+    supportedChains,
+    schema: buildSIWxSchema(),
+    _options: options
+  };
+  return { [SIGN_IN_WITH_X]: declaration };
+}
+
+// src/sign-in-with-x/parse.ts
+var import_utils = require("@bankofai/x402-core/utils");
+function parseSIWxHeader(header) {
+  if (!import_utils.Base64EncodedRegex.test(header)) {
+    throw new Error("Invalid SIWX header: not valid base64");
+  }
+  const jsonStr = (0, import_utils.safeBase64Decode)(header);
+  let rawPayload;
+  try {
+    rawPayload = JSON.parse(jsonStr);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("Invalid SIWX header: not valid JSON");
+    }
+    throw error;
+  }
+  const parsed = SIWxPayloadSchema.safeParse(rawPayload);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
+    throw new Error(`Invalid SIWX header: ${issues}`);
+  }
+  return parsed.data;
+}
+
+// src/sign-in-with-x/validate.ts
+var DEFAULT_MAX_AGE_MS = 5 * 60 * 1e3;
+async function validateSIWxMessage(message, expectedResourceUri, options = {}) {
+  const expectedUrl = new URL(expectedResourceUri);
+  const maxAge = options.maxAge ?? DEFAULT_MAX_AGE_MS;
+  if (message.domain !== expectedUrl.hostname) {
+    return {
+      valid: false,
+      error: `Domain mismatch: expected "${expectedUrl.hostname}", got "${message.domain}"`
+    };
+  }
+  if (!message.uri.startsWith(expectedUrl.origin)) {
+    return {
+      valid: false,
+      error: `URI mismatch: expected origin "${expectedUrl.origin}", got "${message.uri}"`
+    };
+  }
+  const issuedAt = new Date(message.issuedAt);
+  if (isNaN(issuedAt.getTime())) {
+    return {
+      valid: false,
+      error: "Invalid issuedAt timestamp"
+    };
+  }
+  const age = Date.now() - issuedAt.getTime();
+  if (age > maxAge) {
+    return {
+      valid: false,
+      error: `Message too old: ${Math.round(age / 1e3)}s exceeds ${maxAge / 1e3}s limit`
+    };
+  }
+  if (age < 0) {
+    return {
+      valid: false,
+      error: "issuedAt is in the future"
+    };
+  }
+  if (message.expirationTime) {
+    const expiration = new Date(message.expirationTime);
+    if (isNaN(expiration.getTime())) {
+      return {
+        valid: false,
+        error: "Invalid expirationTime timestamp"
+      };
+    }
+    if (expiration < /* @__PURE__ */ new Date()) {
+      return {
+        valid: false,
+        error: "Message expired"
+      };
+    }
+  }
+  if (message.notBefore) {
+    const notBefore = new Date(message.notBefore);
+    if (isNaN(notBefore.getTime())) {
+      return {
+        valid: false,
+        error: "Invalid notBefore timestamp"
+      };
+    }
+    if (/* @__PURE__ */ new Date() < notBefore) {
+      return {
+        valid: false,
+        error: "Message not yet valid (notBefore is in the future)"
+      };
+    }
+  }
+  if (options.checkNonce) {
+    const nonceValid = await options.checkNonce(message.nonce);
+    if (!nonceValid) {
+      return {
+        valid: false,
+        error: "Nonce validation failed (possible replay attack)"
+      };
+    }
+  }
+  return { valid: true };
+}
+
+// src/sign-in-with-x/evm.ts
+var import_viem = require("viem");
+var import_siwe = require("@signinwithethereum/siwe");
+function extractEVMChainId(chainId) {
+  const match = /^eip155:(\d+)$/.exec(chainId);
+  if (!match) {
+    throw new Error(`Invalid EVM chainId format: ${chainId}. Expected eip155:<number>`);
+  }
+  return parseInt(match[1], 10);
+}
+function formatSIWEMessage(info, address) {
+  const numericChainId = extractEVMChainId(info.chainId);
+  const siweMessage = new import_siwe.SiweMessage({
+    domain: info.domain,
+    address,
+    statement: info.statement,
+    uri: info.uri,
+    version: info.version,
+    chainId: numericChainId,
+    nonce: info.nonce,
+    issuedAt: info.issuedAt,
+    expirationTime: info.expirationTime,
+    notBefore: info.notBefore,
+    requestId: info.requestId,
+    resources: info.resources
+  });
+  return siweMessage.prepareMessage();
+}
+async function verifyEVMSignature(message, address, signature, verifier) {
+  const args = {
+    address,
+    message,
+    signature
+  };
+  if (verifier) {
+    return verifier(args);
+  }
+  return (0, import_viem.verifyMessage)(args);
+}
+function isEVMSigner(signer) {
+  if ("signMessages" in signer && typeof signer.signMessages === "function") {
+    return false;
+  }
+  if ("publicKey" in signer && signer.publicKey) {
+    const pk = signer.publicKey;
+    if (typeof pk === "object" && pk !== null && "toBase58" in pk) {
+      return false;
+    }
+    if (typeof pk === "string" && !pk.startsWith("0x")) {
+      return false;
+    }
+  }
+  if ("account" in signer && signer.account && typeof signer.account === "object") {
+    const account = signer.account;
+    if (account.address && account.address.startsWith("0x")) {
+      return true;
+    }
+  }
+  if ("address" in signer && typeof signer.address === "string" && signer.address.startsWith("0x")) {
+    return true;
+  }
+  return false;
+}
+
+// src/sign-in-with-x/verify.ts
+async function verifySIWxSignature(payload, options) {
+  try {
+    if (payload.chainId.startsWith("eip155:")) {
+      return verifyEVMPayload(payload, options?.evmVerifier);
+    }
+    if (payload.chainId.startsWith("solana:")) {
+      return verifySolanaPayload(payload);
+    }
+    return {
+      valid: false,
+      error: `Unsupported chain namespace: ${payload.chainId}. Supported: eip155:* (EVM), solana:* (Solana)`
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Verification failed"
+    };
+  }
+}
+async function verifyEVMPayload(payload, verifier) {
+  const message = formatSIWEMessage(
+    {
+      domain: payload.domain,
+      uri: payload.uri,
+      statement: payload.statement,
+      version: payload.version,
+      chainId: payload.chainId,
+      type: payload.type,
+      nonce: payload.nonce,
+      issuedAt: payload.issuedAt,
+      expirationTime: payload.expirationTime,
+      notBefore: payload.notBefore,
+      requestId: payload.requestId,
+      resources: payload.resources
+    },
+    payload.address
+  );
+  try {
+    const valid = await verifyEVMSignature(message, payload.address, payload.signature, verifier);
+    if (!valid) {
+      return {
+        valid: false,
+        error: "Signature verification failed"
+      };
+    }
+    return {
+      valid: true,
+      address: payload.address
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Signature verification failed"
+    };
+  }
+}
+function verifySolanaPayload(payload) {
+  const message = formatSIWSMessage(
+    {
+      domain: payload.domain,
+      uri: payload.uri,
+      statement: payload.statement,
+      version: payload.version,
+      chainId: payload.chainId,
+      type: payload.type,
+      nonce: payload.nonce,
+      issuedAt: payload.issuedAt,
+      expirationTime: payload.expirationTime,
+      notBefore: payload.notBefore,
+      requestId: payload.requestId,
+      resources: payload.resources
+    },
+    payload.address
+  );
+  let signature;
+  let publicKey;
+  try {
+    signature = decodeBase58(payload.signature);
+    publicKey = decodeBase58(payload.address);
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Invalid Base58 encoding: ${error instanceof Error ? error.message : "decode failed"}`
+    };
+  }
+  if (signature.length !== 64) {
+    return {
+      valid: false,
+      error: `Invalid signature length: expected 64 bytes, got ${signature.length}`
+    };
+  }
+  if (publicKey.length !== 32) {
+    return {
+      valid: false,
+      error: `Invalid public key length: expected 32 bytes, got ${publicKey.length}`
+    };
+  }
+  const valid = verifySolanaSignature(message, signature, publicKey);
+  if (!valid) {
+    return {
+      valid: false,
+      error: "Solana signature verification failed"
+    };
+  }
+  return {
+    valid: true,
+    address: payload.address
+  };
+}
+
+// src/sign-in-with-x/sign.ts
+function getEVMAddress(signer) {
+  if (signer.account?.address) {
+    return signer.account.address;
+  }
+  if (signer.address) {
+    return signer.address;
+  }
+  throw new Error("EVM signer missing address");
+}
+function getSolanaAddress(signer) {
+  if ("address" in signer && signer.address) {
+    return signer.address;
+  }
+  if ("publicKey" in signer) {
+    const pk = signer.publicKey;
+    return typeof pk === "string" ? pk : pk.toBase58();
+  }
+  throw new Error("Solana signer missing address or publicKey");
+}
+async function signEVMMessage(message, signer) {
+  if (signer.account) {
+    return signer.signMessage({ message, account: signer.account });
+  }
+  return signer.signMessage({ message });
+}
+async function signSolanaMessage(message, signer) {
+  const messageBytes = new TextEncoder().encode(message);
+  if ("signMessages" in signer) {
+    const results = await signer.signMessages([{ content: messageBytes, signatures: {} }]);
+    const sigDict = results[0];
+    const signatureBytes = Object.values(sigDict)[0];
+    return encodeBase58(signatureBytes);
+  }
+  if ("signMessage" in signer) {
+    const signatureBytes = await signer.signMessage(messageBytes);
+    return encodeBase58(signatureBytes);
+  }
+  throw new Error("Solana signer missing signMessage or signMessages method");
+}
+
+// src/sign-in-with-x/message.ts
+function createSIWxMessage(serverInfo, address) {
+  if (serverInfo.chainId.startsWith("eip155:")) {
+    return formatSIWEMessage(serverInfo, address);
+  }
+  if (serverInfo.chainId.startsWith("solana:")) {
+    return formatSIWSMessage(serverInfo, address);
+  }
+  throw new Error(
+    `Unsupported chain namespace: ${serverInfo.chainId}. Supported: eip155:* (EVM), solana:* (Solana)`
+  );
+}
+
+// src/sign-in-with-x/client.ts
+async function createSIWxPayload(serverExtension, signer) {
+  const isSolana = serverExtension.chainId.startsWith("solana:");
+  const address = isSolana ? getSolanaAddress(signer) : getEVMAddress(signer);
+  const message = createSIWxMessage(serverExtension, address);
+  const signature = isSolana ? await signSolanaMessage(message, signer) : await signEVMMessage(message, signer);
+  return {
+    domain: serverExtension.domain,
+    address,
+    statement: serverExtension.statement,
+    uri: serverExtension.uri,
+    version: serverExtension.version,
+    chainId: serverExtension.chainId,
+    type: serverExtension.type,
+    nonce: serverExtension.nonce,
+    issuedAt: serverExtension.issuedAt,
+    expirationTime: serverExtension.expirationTime,
+    notBefore: serverExtension.notBefore,
+    requestId: serverExtension.requestId,
+    resources: serverExtension.resources,
+    signatureScheme: serverExtension.signatureScheme,
+    signature
+  };
+}
+
+// src/sign-in-with-x/encode.ts
+var import_utils2 = require("@bankofai/x402-core/utils");
+function encodeSIWxHeader(payload) {
+  return (0, import_utils2.safeBase64Encode)(JSON.stringify(payload));
+}
+
+// src/sign-in-with-x/hooks.ts
+function createSIWxSettleHook(options) {
+  const { storage, onEvent } = options;
+  return async (ctx) => {
+    if (!ctx.result.success) return;
+    const address = ctx.result.payer;
+    if (!address) return;
+    const resourceUrl = ctx.paymentPayload.resource?.url;
+    if (!resourceUrl) return;
+    const resource = new URL(resourceUrl).pathname;
+    await storage.recordPayment(resource, address);
+    onEvent?.({ type: "payment_recorded", resource, address });
+  };
+}
+function createSIWxRequestHook(options) {
+  const { storage, verifyOptions, onEvent } = options;
+  const hasUsedNonce = typeof storage.hasUsedNonce === "function";
+  const hasRecordNonce = typeof storage.recordNonce === "function";
+  if (hasUsedNonce !== hasRecordNonce) {
+    throw new Error(
+      "SIWxStorage nonce tracking requires both hasUsedNonce and recordNonce to be implemented"
+    );
+  }
+  return async (context, routeConfig) => {
+    const header = context.adapter.getHeader(SIGN_IN_WITH_X) || context.adapter.getHeader(SIGN_IN_WITH_X.toLowerCase());
+    if (!header) return;
+    try {
+      const payload = parseSIWxHeader(header);
+      const resourceUri = context.adapter.getUrl();
+      const validation = await validateSIWxMessage(payload, resourceUri);
+      if (!validation.valid) {
+        onEvent?.({ type: "validation_failed", resource: context.path, error: validation.error });
+        return;
+      }
+      const verification = await verifySIWxSignature(payload, verifyOptions);
+      if (!verification.valid || !verification.address) {
+        onEvent?.({ type: "validation_failed", resource: context.path, error: verification.error });
+        return;
+      }
+      if (storage.hasUsedNonce) {
+        const nonceUsed = await storage.hasUsedNonce(payload.nonce);
+        if (nonceUsed) {
+          onEvent?.({ type: "nonce_reused", resource: context.path, nonce: payload.nonce });
+          return;
+        }
+      }
+      const isAuthOnly = Array.isArray(routeConfig?.accepts) && routeConfig.accepts.length === 0;
+      const shouldGrant = isAuthOnly || await storage.hasPaid(context.path, verification.address);
+      if (shouldGrant) {
+        if (storage.recordNonce) {
+          await storage.recordNonce(payload.nonce);
+        }
+        onEvent?.({
+          type: "access_granted",
+          resource: context.path,
+          address: verification.address
+        });
+        return { grantAccess: true };
+      }
+    } catch (err) {
+      onEvent?.({
+        type: "validation_failed",
+        resource: context.path,
+        error: err instanceof Error ? err.message : "Unknown error"
+      });
+    }
+  };
+}
+function createSIWxClientHook(signer) {
+  const signerIsSolana = isSolanaSigner(signer);
+  const expectedSignatureType = signerIsSolana ? "ed25519" : "eip191";
+  return async (context) => {
+    const extensions = context.paymentRequired.extensions ?? {};
+    const siwxExtension = extensions[SIGN_IN_WITH_X];
+    if (!siwxExtension?.supportedChains) return;
+    try {
+      const matchingChain = siwxExtension.supportedChains.find(
+        (chain) => chain.type === expectedSignatureType
+      );
+      if (!matchingChain) {
+        return;
+      }
+      const completeInfo = {
+        ...siwxExtension.info,
+        chainId: matchingChain.chainId,
+        type: matchingChain.type
+      };
+      const payload = await createSIWxPayload(completeInfo, signer);
+      const header = encodeSIWxHeader(payload);
+      return { headers: { [SIGN_IN_WITH_X]: header } };
+    } catch {
+    }
+  };
+}
+function createSIWxClientExtension(options) {
+  const hooks = options.signers.map(createSIWxClientHook);
+  return {
+    key: SIGN_IN_WITH_X,
+    transportHooks: {
+      http: {
+        onPaymentRequired: async (_declaration, context) => {
+          for (const hook of hooks) {
+            const result = await hook(context);
+            if (result?.headers) return result;
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/sign-in-with-x/server.ts
+async function enrichSIWxPaymentRequiredResponse(declaration, context) {
+  const decl = declaration;
+  const opts = decl._options ?? {};
+  const resourceUri = opts.resourceUri ?? context.resourceInfo.url;
+  let domain = opts.domain;
+  if (!domain && resourceUri) {
+    try {
+      domain = new URL(resourceUri).hostname;
+    } catch {
+      domain = void 0;
+    }
+  }
+  let supportedNetworks;
+  if (opts.network) {
+    supportedNetworks = Array.isArray(opts.network) ? opts.network : [opts.network];
+  } else {
+    supportedNetworks = [...new Set(context.requirements.map((r) => r.network))];
+  }
+  const nonce = Array.from(globalThis.crypto.getRandomValues(new Uint8Array(16))).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const issuedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const expirationTime = opts.expirationSeconds !== void 0 ? new Date(Date.now() + opts.expirationSeconds * 1e3).toISOString() : void 0;
+  const info = {
+    domain: domain ?? "",
+    uri: resourceUri,
+    version: opts.version ?? "1",
+    nonce,
+    issuedAt,
+    resources: [resourceUri]
+  };
+  if (expirationTime) {
+    info.expirationTime = expirationTime;
+  }
+  if (opts.statement) {
+    info.statement = opts.statement;
+  }
+  const supportedChains = supportedNetworks.map((network) => ({
+    chainId: network,
+    type: getSignatureType(network)
+  }));
+  return {
+    info,
+    supportedChains,
+    schema: buildSIWxSchema()
+  };
+}
+function createSIWxResourceServerExtension(options) {
+  const settleHook = createSIWxSettleHook(options);
+  const requestHook = createSIWxRequestHook(options);
+  return {
+    key: SIGN_IN_WITH_X,
+    enrichPaymentRequiredResponse: enrichSIWxPaymentRequiredResponse,
+    transportHooks: {
+      http: {
+        onProtectedRequest: async (_declaration, context, routeConfig) => requestHook(context, routeConfig)
+      }
+    },
+    hooks: {
+      onAfterSettle: async (_declaration, context) => settleHook(context)
+    }
+  };
+}
+
+// src/sign-in-with-x/fetch.ts
+var import_http = require("@bankofai/x402-core/http");
+function wrapFetchWithSIWx(fetch2, signer) {
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const clonedRequest = request.clone();
+    const response = await fetch2(request);
+    if (response.status !== 402) {
+      return response;
+    }
+    const paymentRequiredHeader = response.headers.get("PAYMENT-REQUIRED");
+    if (!paymentRequiredHeader) {
+      return response;
+    }
+    const paymentRequired = (0, import_http.decodePaymentRequiredHeader)(paymentRequiredHeader);
+    const siwxExtension = paymentRequired.extensions?.[SIGN_IN_WITH_X];
+    if (!siwxExtension?.supportedChains) {
+      return response;
+    }
+    if (clonedRequest.headers.has(SIGN_IN_WITH_X)) {
+      throw new Error("SIWX authentication already attempted");
+    }
+    const paymentNetwork = paymentRequired.accepts?.[0]?.network;
+    if (!paymentNetwork) {
+      return response;
+    }
+    const matchingChain = siwxExtension.supportedChains.find(
+      (chain) => chain.chainId === paymentNetwork
+    );
+    if (!matchingChain) {
+      return response;
+    }
+    const completeInfo = {
+      ...siwxExtension.info,
+      chainId: matchingChain.chainId,
+      type: matchingChain.type
+    };
+    const payload = await createSIWxPayload(completeInfo, signer);
+    const siwxHeader = encodeSIWxHeader(payload);
+    clonedRequest.headers.set(SIGN_IN_WITH_X, siwxHeader);
+    return fetch2(clonedRequest);
+  };
+}
+
+// src/sign-in-with-x/storage.ts
+var InMemorySIWxStorage = class {
+  constructor() {
+    this.paidAddresses = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Check if an address has paid for a resource.
+   *
+   * @param resource - The resource path
+   * @param address - The wallet address to check
+   * @returns True if the address has paid
+   */
+  hasPaid(resource, address) {
+    return this.paidAddresses.get(resource)?.has(address.toLowerCase()) ?? false;
+  }
+  /**
+   * Record that an address has paid for a resource.
+   *
+   * @param resource - The resource path
+   * @param address - The wallet address that paid
+   */
+  recordPayment(resource, address) {
+    if (!this.paidAddresses.has(resource)) {
+      this.paidAddresses.set(resource, /* @__PURE__ */ new Set());
+    }
+    this.paidAddresses.get(resource).add(address.toLowerCase());
+  }
+};
+
+// src/offer-receipt/types.ts
+var OFFER_RECEIPT = "offer-receipt";
+function isJWSSignedOffer(offer) {
+  return offer.format === "jws";
+}
+function isEIP712SignedOffer(offer) {
+  return offer.format === "eip712";
+}
+function isJWSSignedReceipt(receipt) {
+  return receipt.format === "jws";
+}
+function isEIP712SignedReceipt(receipt) {
+  return receipt.format === "eip712";
+}
+function isJWSSigner(signer) {
+  return signer.format === "jws";
+}
+function isEIP712Signer(signer) {
+  return signer.format === "eip712";
+}
+
+// src/offer-receipt/signing.ts
+var jose2 = __toESM(require("jose"));
+var import_viem2 = require("viem");
+
+// src/offer-receipt/did.ts
+var jose = __toESM(require("jose"));
+var import_base2 = require("@scure/base");
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_nist = require("@noble/curves/nist");
+var MULTICODEC_ED25519_PUB = 237;
+var MULTICODEC_SECP256K1_PUB = 231;
+var MULTICODEC_P256_PUB = 4608;
+async function extractPublicKeyFromKid(kid) {
+  const [didPart, fragment] = kid.split("#");
+  const parts = didPart.split(":");
+  if (parts.length < 3 || parts[0] !== "did") {
+    throw new Error(`Invalid DID format: ${kid}`);
+  }
+  const method = parts[1];
+  const identifier = parts.slice(2).join(":");
+  switch (method) {
+    case "key":
+      return extractKeyFromDidKey(identifier);
+    case "jwk":
+      return extractKeyFromDidJwk(identifier);
+    case "web":
+      return resolveDidWeb(identifier, fragment);
+    default:
+      throw new Error(
+        `Unsupported DID method "${method}". Supported: did:key, did:jwk, did:web. Provide the public key directly for other methods.`
+      );
+  }
+}
+async function extractKeyFromDidKey(identifier) {
+  if (!identifier.startsWith("z")) {
+    throw new Error(`Unsupported multibase encoding. Expected 'z' (base58-btc).`);
+  }
+  const decoded = import_base2.base58.decode(identifier.slice(1));
+  const { codec, keyBytes } = readMulticodec(decoded);
+  switch (codec) {
+    case MULTICODEC_ED25519_PUB:
+      return importAsymmetricJWK({
+        kty: "OKP",
+        crv: "Ed25519",
+        x: jose.base64url.encode(keyBytes)
+      });
+    case MULTICODEC_SECP256K1_PUB: {
+      const point = import_secp256k1.secp256k1.Point.fromHex(keyBytes);
+      const uncompressed = point.toBytes(false);
+      return importAsymmetricJWK({
+        kty: "EC",
+        crv: "secp256k1",
+        x: jose.base64url.encode(uncompressed.slice(1, 33)),
+        y: jose.base64url.encode(uncompressed.slice(33, 65))
+      });
+    }
+    case MULTICODEC_P256_PUB: {
+      const point = import_nist.p256.Point.fromHex(keyBytes);
+      const uncompressed = point.toBytes(false);
+      return importAsymmetricJWK({
+        kty: "EC",
+        crv: "P-256",
+        x: jose.base64url.encode(uncompressed.slice(1, 33)),
+        y: jose.base64url.encode(uncompressed.slice(33, 65))
+      });
+    }
+    default:
+      throw new Error(
+        `Unsupported key type in did:key (multicodec: 0x${codec.toString(16)}). Supported: Ed25519, secp256k1, P-256.`
+      );
+  }
+}
+async function extractKeyFromDidJwk(identifier) {
+  const jwkJson = new TextDecoder().decode(jose.base64url.decode(identifier));
+  const jwk = JSON.parse(jwkJson);
+  return importAsymmetricJWK(jwk);
+}
+async function resolveDidWeb(identifier, fragment) {
+  const parts = identifier.split(":");
+  const domain = decodeURIComponent(parts[0]);
+  const path = parts.slice(1).map(decodeURIComponent).join("/");
+  const host = domain.split(":")[0];
+  const scheme = host === "localhost" || host === "127.0.0.1" ? "http" : "https";
+  const url = path ? `${scheme}://${domain}/${path}/did.json` : `${scheme}://${domain}/.well-known/did.json`;
+  let didDocument;
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: "application/did+json, application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    didDocument = await response.json();
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve did:web:${identifier}: ${error instanceof Error ? error.message : error}`
+    );
+  }
+  const fullDid = `did:web:${identifier}`;
+  const keyId = fragment ? `${fullDid}#${fragment}` : void 0;
+  const method = findVerificationMethod(didDocument, keyId);
+  if (!method) {
+    throw new Error(`No verification method found for ${keyId || fullDid}`);
+  }
+  if (method.publicKeyJwk) {
+    return importAsymmetricJWK(method.publicKeyJwk);
+  }
+  if (method.publicKeyMultibase) {
+    return extractKeyFromDidKey(method.publicKeyMultibase);
+  }
+  throw new Error(`Verification method ${method.id} has no supported key format`);
+}
+function readMulticodec(bytes) {
+  let codec = 0;
+  let shift = 0;
+  let offset = 0;
+  for (const byte of bytes) {
+    codec |= (byte & 127) << shift;
+    offset++;
+    if ((byte & 128) === 0) break;
+    shift += 7;
+  }
+  return { codec, keyBytes: bytes.slice(offset) };
+}
+async function importAsymmetricJWK(jwk) {
+  const key = await jose.importJWK(jwk);
+  if (key instanceof Uint8Array) {
+    throw new Error("Symmetric keys are not supported");
+  }
+  return key;
+}
+function findVerificationMethod(doc, keyId) {
+  const methods = doc.verificationMethod || [];
+  if (keyId) {
+    return methods.find((m) => m.id === keyId);
+  }
+  for (const ref of doc.assertionMethod || []) {
+    if (typeof ref === "string") {
+      const m = methods.find((m2) => m2.id === ref);
+      if (m) return m;
+    } else {
+      return ref;
+    }
+  }
+  for (const ref of doc.authentication || []) {
+    if (typeof ref === "string") {
+      const m = methods.find((m2) => m2.id === ref);
+      if (m) return m;
+    } else {
+      return ref;
+    }
+  }
+  return methods[0];
+}
+
+// src/offer-receipt/signing.ts
+function canonicalize(value) {
+  return serializeValue(value);
+}
+function serializeValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "null";
+  const type = typeof value;
+  if (type === "boolean") return value ? "true" : "false";
+  if (type === "number") return serializeNumber(value);
+  if (type === "string") return serializeString(value);
+  if (Array.isArray(value)) return serializeArray(value);
+  if (type === "object") return serializeObject(value);
+  throw new Error(`Cannot canonicalize value of type ${type}`);
+}
+function serializeNumber(num) {
+  if (!Number.isFinite(num)) throw new Error("Cannot canonicalize Infinity or NaN");
+  if (Object.is(num, -0)) return "0";
+  return String(num);
+}
+function serializeString(str) {
+  let result = '"';
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    const code = str.charCodeAt(i);
+    if (code < 32) {
+      result += "\\u" + code.toString(16).padStart(4, "0");
+    } else if (char === '"') {
+      result += '\\"';
+    } else if (char === "\\") {
+      result += "\\\\";
+    } else {
+      result += char;
+    }
+  }
+  return result + '"';
+}
+function serializeArray(arr) {
+  return "[" + arr.map(serializeValue).join(",") + "]";
+}
+function serializeObject(obj) {
+  const keys = Object.keys(obj).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const pairs = [];
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      pairs.push(serializeString(key) + ":" + serializeValue(value));
+    }
+  }
+  return "{" + pairs.join(",") + "}";
+}
+async function hashCanonical(obj) {
+  const canonical = canonicalize(obj);
+  const data = new TextEncoder().encode(canonical);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return new Uint8Array(hashBuffer);
+}
+function getCanonicalBytes(obj) {
+  return new TextEncoder().encode(canonicalize(obj));
+}
+async function createJWS(payload, signer) {
+  const headerObj = { alg: signer.algorithm, kid: signer.kid };
+  const headerB64 = jose2.base64url.encode(new TextEncoder().encode(JSON.stringify(headerObj)));
+  const canonical = canonicalize(payload);
+  const payloadB64 = jose2.base64url.encode(new TextEncoder().encode(canonical));
+  const signingInput = new TextEncoder().encode(`${headerB64}.${payloadB64}`);
+  const signatureB64 = await signer.sign(signingInput);
+  return `${headerB64}.${payloadB64}.${signatureB64}`;
+}
+function extractJWSHeader(jws) {
+  const parts = jws.split(".");
+  if (parts.length !== 3) throw new Error("Invalid JWS format");
+  const headerJson = jose2.base64url.decode(parts[0]);
+  return JSON.parse(new TextDecoder().decode(headerJson));
+}
+function extractJWSPayload(jws) {
+  const parts = jws.split(".");
+  if (parts.length !== 3) throw new Error("Invalid JWS format");
+  const payloadJson = jose2.base64url.decode(parts[1]);
+  return JSON.parse(new TextDecoder().decode(payloadJson));
+}
+function createOfferDomain() {
+  return { name: "x402 offer", version: "1", chainId: 1 };
+}
+function createReceiptDomain() {
+  return { name: "x402 receipt", version: "1", chainId: 1 };
+}
+var OFFER_TYPES = {
+  Offer: [
+    { name: "version", type: "uint256" },
+    { name: "resourceUrl", type: "string" },
+    { name: "scheme", type: "string" },
+    { name: "network", type: "string" },
+    { name: "asset", type: "string" },
+    { name: "payTo", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "validUntil", type: "uint256" }
+  ]
+};
+var RECEIPT_TYPES = {
+  Receipt: [
+    { name: "version", type: "uint256" },
+    { name: "network", type: "string" },
+    { name: "resourceUrl", type: "string" },
+    { name: "payer", type: "string" },
+    { name: "issuedAt", type: "uint256" },
+    { name: "transaction", type: "string" }
+  ]
+};
+function prepareOfferForEIP712(payload) {
+  return {
+    version: BigInt(payload.version),
+    resourceUrl: payload.resourceUrl,
+    scheme: payload.scheme,
+    network: payload.network,
+    asset: payload.asset,
+    payTo: payload.payTo,
+    amount: payload.amount,
+    validUntil: BigInt(payload.validUntil)
+  };
+}
+function prepareReceiptForEIP712(payload) {
+  return {
+    version: BigInt(payload.version),
+    network: payload.network,
+    resourceUrl: payload.resourceUrl,
+    payer: payload.payer,
+    issuedAt: BigInt(payload.issuedAt),
+    transaction: payload.transaction
+  };
+}
+function hashOfferTypedData(payload) {
+  return (0, import_viem2.hashTypedData)({
+    domain: createOfferDomain(),
+    types: OFFER_TYPES,
+    primaryType: "Offer",
+    message: prepareOfferForEIP712(payload)
+  });
+}
+function hashReceiptTypedData(payload) {
+  return (0, import_viem2.hashTypedData)({
+    domain: createReceiptDomain(),
+    types: RECEIPT_TYPES,
+    primaryType: "Receipt",
+    message: prepareReceiptForEIP712(payload)
+  });
+}
+async function signOfferEIP712(payload, signTypedData) {
+  return signTypedData({
+    domain: createOfferDomain(),
+    types: OFFER_TYPES,
+    primaryType: "Offer",
+    message: prepareOfferForEIP712(payload)
+  });
+}
+async function signReceiptEIP712(payload, signTypedData) {
+  return signTypedData({
+    domain: createReceiptDomain(),
+    types: RECEIPT_TYPES,
+    primaryType: "Receipt",
+    message: prepareReceiptForEIP712(payload)
+  });
+}
+function extractEIP155ChainId(network) {
+  const match = network.match(/^eip155:(\d+)$/);
+  if (!match) {
+    throw new Error(`Invalid network format: ${network}. Expected "eip155:<chainId>"`);
+  }
+  return parseInt(match[1], 10);
+}
+var V1_EVM_NETWORK_CHAIN_IDS = {
+  ethereum: 1,
+  sepolia: 11155111,
+  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
+};
+var V1_SOLANA_NETWORKS = {
+  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "solana-devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  "solana-testnet": "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z"
+};
+function convertNetworkStringToCAIP2(network) {
+  if (network.includes(":")) return network;
+  const chainId = V1_EVM_NETWORK_CHAIN_IDS[network.toLowerCase()];
+  if (chainId !== void 0) {
+    return `eip155:${chainId}`;
+  }
+  const solanaNetwork = V1_SOLANA_NETWORKS[network.toLowerCase()];
+  if (solanaNetwork) {
+    return solanaNetwork;
+  }
+  throw new Error(
+    `Unknown network identifier: "${network}". Expected CAIP-2 format (e.g., "eip155:8453") or v1 name (e.g., "base", "solana").`
+  );
+}
+function extractChainIdFromCAIP2(network) {
+  const [namespace, reference] = network.split(":");
+  if (namespace === "eip155" && reference) {
+    const chainId = parseInt(reference, 10);
+    return isNaN(chainId) ? void 0 : chainId;
+  }
+  return void 0;
+}
+var DEFAULT_MAX_TIMEOUT_SECONDS = 300;
+var EXTENSION_VERSION = 1;
+function createOfferPayload(resourceUrl, input) {
+  const now = Math.floor(Date.now() / 1e3);
+  const offerValiditySeconds = input.offerValiditySeconds ?? DEFAULT_MAX_TIMEOUT_SECONDS;
+  return {
+    version: EXTENSION_VERSION,
+    resourceUrl,
+    scheme: input.scheme,
+    network: input.network,
+    asset: input.asset,
+    payTo: input.payTo,
+    amount: input.amount,
+    validUntil: now + offerValiditySeconds
+  };
+}
+async function createOfferJWS(resourceUrl, input, signer) {
+  const payload = createOfferPayload(resourceUrl, input);
+  const jws = await createJWS(payload, signer);
+  return {
+    format: "jws",
+    acceptIndex: input.acceptIndex,
+    signature: jws
+  };
+}
+async function createOfferEIP712(resourceUrl, input, signTypedData) {
+  const payload = createOfferPayload(resourceUrl, input);
+  const signature = await signOfferEIP712(payload, signTypedData);
+  return {
+    format: "eip712",
+    acceptIndex: input.acceptIndex,
+    payload,
+    signature
+  };
+}
+function extractOfferPayload(offer) {
+  if (isJWSSignedOffer(offer)) {
+    return extractJWSPayload(offer.signature);
+  } else if (isEIP712SignedOffer(offer)) {
+    return offer.payload;
+  }
+  throw new Error(`Unknown offer format: ${offer.format}`);
+}
+function createReceiptPayloadForEIP712(input) {
+  return {
+    version: EXTENSION_VERSION,
+    network: input.network,
+    resourceUrl: input.resourceUrl,
+    payer: input.payer,
+    issuedAt: Math.floor(Date.now() / 1e3),
+    transaction: input.transaction ?? ""
+  };
+}
+function createReceiptPayloadForJWS(input) {
+  const payload = {
+    version: EXTENSION_VERSION,
+    network: input.network,
+    resourceUrl: input.resourceUrl,
+    payer: input.payer,
+    issuedAt: Math.floor(Date.now() / 1e3)
+  };
+  if (input.transaction) {
+    payload.transaction = input.transaction;
+  }
+  return payload;
+}
+async function createReceiptJWS(input, signer) {
+  const payload = createReceiptPayloadForJWS(input);
+  const jws = await createJWS(payload, signer);
+  return { format: "jws", signature: jws };
+}
+async function createReceiptEIP712(input, signTypedData) {
+  const payload = createReceiptPayloadForEIP712(input);
+  const signature = await signReceiptEIP712(payload, signTypedData);
+  return { format: "eip712", payload, signature };
+}
+function extractReceiptPayload(receipt) {
+  if (isJWSSignedReceipt(receipt)) {
+    return extractJWSPayload(receipt.signature);
+  } else if (isEIP712SignedReceipt(receipt)) {
+    return receipt.payload;
+  }
+  throw new Error(`Unknown receipt format: ${receipt.format}`);
+}
+async function verifyOfferSignatureEIP712(offer) {
+  if (offer.format !== "eip712") {
+    throw new Error(`Expected eip712 format, got ${offer.format}`);
+  }
+  if (!offer.payload || !("scheme" in offer.payload)) {
+    throw new Error("Invalid offer: missing or malformed payload");
+  }
+  const signer = await (0, import_viem2.recoverTypedDataAddress)({
+    domain: createOfferDomain(),
+    types: OFFER_TYPES,
+    primaryType: "Offer",
+    message: prepareOfferForEIP712(offer.payload),
+    signature: offer.signature
+  });
+  return { signer, payload: offer.payload };
+}
+async function verifyReceiptSignatureEIP712(receipt) {
+  if (receipt.format !== "eip712") {
+    throw new Error(`Expected eip712 format, got ${receipt.format}`);
+  }
+  if (!receipt.payload || !("payer" in receipt.payload)) {
+    throw new Error("Invalid receipt: missing or malformed payload");
+  }
+  const signer = await (0, import_viem2.recoverTypedDataAddress)({
+    domain: createReceiptDomain(),
+    types: RECEIPT_TYPES,
+    primaryType: "Receipt",
+    message: prepareReceiptForEIP712(receipt.payload),
+    signature: receipt.signature
+  });
+  return { signer, payload: receipt.payload };
+}
+async function verifyOfferSignatureJWS(offer, publicKey) {
+  if (offer.format !== "jws") {
+    throw new Error(`Expected jws format, got ${offer.format}`);
+  }
+  const key = await resolveVerificationKey(offer.signature, publicKey);
+  const { payload } = await jose2.compactVerify(offer.signature, key);
+  return JSON.parse(new TextDecoder().decode(payload));
+}
+async function verifyReceiptSignatureJWS(receipt, publicKey) {
+  if (receipt.format !== "jws") {
+    throw new Error(`Expected jws format, got ${receipt.format}`);
+  }
+  const key = await resolveVerificationKey(receipt.signature, publicKey);
+  const { payload } = await jose2.compactVerify(receipt.signature, key);
+  return JSON.parse(new TextDecoder().decode(payload));
+}
+async function resolveVerificationKey(jws, providedKey) {
+  if (providedKey) {
+    if ("kty" in providedKey) {
+      const key = await jose2.importJWK(providedKey);
+      if (key instanceof Uint8Array) {
+        throw new Error("Symmetric keys are not supported for JWS verification");
+      }
+      return key;
+    }
+    return providedKey;
+  }
+  const header = extractJWSHeader(jws);
+  if (!header.kid) {
+    throw new Error("No public key provided and JWS header missing kid");
+  }
+  return extractPublicKeyFromKid(header.kid);
+}
+
+// src/offer-receipt/server.ts
+var OFFER_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    offers: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          format: { type: "string" },
+          acceptIndex: { type: "integer" },
+          payload: {
+            type: "object",
+            properties: {
+              version: { type: "integer" },
+              resourceUrl: { type: "string" },
+              scheme: { type: "string" },
+              network: { type: "string" },
+              asset: { type: "string" },
+              payTo: { type: "string" },
+              amount: { type: "string" },
+              validUntil: { type: "integer" }
+            },
+            required: ["version", "resourceUrl", "scheme", "network", "asset", "payTo", "amount"]
+          },
+          signature: { type: "string" }
+        },
+        required: ["format", "signature"]
+      }
+    }
+  },
+  required: ["offers"]
+};
+var RECEIPT_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    receipt: {
+      type: "object",
+      properties: {
+        format: { type: "string" },
+        payload: {
+          type: "object",
+          properties: {
+            version: { type: "integer" },
+            network: { type: "string" },
+            resourceUrl: { type: "string" },
+            payer: { type: "string" },
+            issuedAt: { type: "integer" },
+            transaction: { type: "string" }
+          },
+          required: ["version", "network", "resourceUrl", "payer", "issuedAt"]
+        },
+        signature: { type: "string" }
+      },
+      required: ["format", "signature"]
+    }
+  },
+  required: ["receipt"]
+};
+function requirementsToOfferInput(requirements, acceptIndex, offerValiditySeconds) {
+  return {
+    acceptIndex,
+    scheme: requirements.scheme,
+    network: requirements.network,
+    asset: requirements.asset,
+    payTo: requirements.payTo,
+    amount: requirements.amount,
+    offerValiditySeconds: offerValiditySeconds ?? requirements.maxTimeoutSeconds
+  };
+}
+function createOfferReceiptExtension(issuer) {
+  return {
+    key: OFFER_RECEIPT,
+    // Add signed offers to 402 PaymentRequired response
+    enrichPaymentRequiredResponse: async (declaration, context) => {
+      const config = declaration;
+      const resourceUrl = context.paymentRequiredResponse.resource?.url || context.transportContext?.request?.adapter?.getUrl?.();
+      if (!resourceUrl) {
+        console.warn("[offer-receipt] No resource URL available for signing offers");
+        return void 0;
+      }
+      const offers = [];
+      for (let i = 0; i < context.requirements.length; i++) {
+        const requirement = context.requirements[i];
+        try {
+          const offerInput = requirementsToOfferInput(requirement, i, config?.offerValiditySeconds);
+          const signedOffer = await issuer.issueOffer(resourceUrl, offerInput);
+          offers.push(signedOffer);
+        } catch (error) {
+          console.error(`[offer-receipt] Failed to sign offer for requirement ${i}:`, error);
+        }
+      }
+      if (offers.length === 0) {
+        return void 0;
+      }
+      return {
+        info: {
+          offers
+        },
+        schema: OFFER_SCHEMA
+      };
+    },
+    // Add signed receipt to settlement response
+    enrichSettlementResponse: async (declaration, context) => {
+      const config = declaration;
+      if (!context.result.success) {
+        return void 0;
+      }
+      const payer = context.result.payer;
+      if (!payer) {
+        console.warn("[offer-receipt] No payer available for signing receipt");
+        return void 0;
+      }
+      const network = context.result.network;
+      if (!network) {
+        console.warn("[offer-receipt] No network available for signing receipt");
+        return void 0;
+      }
+      const transaction = context.result.transaction;
+      const resourceUrl = context.transportContext?.request?.adapter?.getUrl?.();
+      if (!resourceUrl) {
+        console.warn("[offer-receipt] No resource URL available for signing receipt");
+        return void 0;
+      }
+      const includeTxHash = config?.includeTxHash === true;
+      try {
+        const signedReceipt = await issuer.issueReceipt(
+          resourceUrl,
+          payer,
+          network,
+          includeTxHash ? transaction || void 0 : void 0
+        );
+        return {
+          info: {
+            receipt: signedReceipt
+          },
+          schema: RECEIPT_SCHEMA
+        };
+      } catch (error) {
+        console.error("[offer-receipt] Failed to sign receipt:", error);
+        return void 0;
+      }
+    }
+  };
+}
+function declareOfferReceiptExtension(config) {
+  return {
+    [OFFER_RECEIPT]: {
+      includeTxHash: config?.includeTxHash,
+      offerValiditySeconds: config?.offerValiditySeconds
+    }
+  };
+}
+function createJWSOfferReceiptIssuer(kid, jwsSigner) {
+  return {
+    kid,
+    format: "jws",
+    async issueOffer(resourceUrl, input) {
+      return createOfferJWS(resourceUrl, input, jwsSigner);
+    },
+    async issueReceipt(resourceUrl, payer, network, transaction) {
+      return createReceiptJWS({ resourceUrl, payer, network, transaction }, jwsSigner);
+    }
+  };
+}
+function createEIP712OfferReceiptIssuer(kid, signTypedData) {
+  return {
+    kid,
+    format: "eip712",
+    async issueOffer(resourceUrl, input) {
+      return createOfferEIP712(resourceUrl, input, signTypedData);
+    },
+    async issueReceipt(resourceUrl, payer, network, transaction) {
+      return createReceiptEIP712({ resourceUrl, payer, network, transaction }, signTypedData);
+    }
+  };
+}
+
+// src/offer-receipt/client.ts
+var import_http2 = require("@bankofai/x402-core/http");
+function verifyReceiptMatchesOffer(receipt, offer, payerAddresses, maxAgeSeconds = 3600) {
+  const payload = extractReceiptPayload(receipt);
+  const resourceUrlMatch = payload.resourceUrl === offer.resourceUrl;
+  const networkMatch = payload.network === offer.network;
+  const payerMatch = payerAddresses.some(
+    (addr) => payload.payer.toLowerCase() === addr.toLowerCase()
+  );
+  const issuedRecently = Math.floor(Date.now() / 1e3) - payload.issuedAt < maxAgeSeconds;
+  return resourceUrlMatch && networkMatch && payerMatch && issuedRecently;
+}
+function extractOffersFromPaymentRequired(paymentRequired) {
+  const extData = paymentRequired.extensions?.[OFFER_RECEIPT];
+  return extData?.info?.offers ?? [];
+}
+function decodeSignedOffers(offers) {
+  return offers.map((offer) => {
+    const payload = extractOfferPayload(offer);
+    return {
+      // Spread payload fields at top level
+      ...payload,
+      // Include metadata
+      signedOffer: offer,
+      format: offer.format,
+      acceptIndex: offer.acceptIndex
+    };
+  });
+}
+function findAcceptsObjectFromSignedOffer(offer, accepts) {
+  const isDecoded = "signedOffer" in offer;
+  const payload = isDecoded ? offer : extractOfferPayload(offer);
+  const acceptIndex = isDecoded ? offer.acceptIndex : offer.acceptIndex;
+  if (acceptIndex !== void 0 && acceptIndex < accepts.length) {
+    const hinted = accepts[acceptIndex];
+    if (hinted.network === payload.network && hinted.scheme === payload.scheme && hinted.asset === payload.asset && hinted.payTo === payload.payTo && hinted.amount === payload.amount) {
+      return hinted;
+    }
+  }
+  return accepts.find(
+    (req) => req.network === payload.network && req.scheme === payload.scheme && req.asset === payload.asset && req.payTo === payload.payTo && req.amount === payload.amount
+  );
+}
+function extractReceiptFromResponse(response) {
+  const paymentResponseHeader = response.headers.get("PAYMENT-RESPONSE") || response.headers.get("X-PAYMENT-RESPONSE");
+  if (!paymentResponseHeader) {
+    return void 0;
+  }
+  try {
+    const settlementResponse = (0, import_http2.decodePaymentResponseHeader)(paymentResponseHeader);
+    const receiptExtData = settlementResponse.extensions?.[OFFER_RECEIPT];
+    return receiptExtData?.info?.receipt;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/payment-identifier/types.ts
+var PAYMENT_IDENTIFIER = "payment-identifier";
+var PAYMENT_ID_MIN_LENGTH = 16;
+var PAYMENT_ID_MAX_LENGTH = 128;
+var PAYMENT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+
+// src/payment-identifier/schema.ts
+var paymentIdentifierSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    required: {
+      type: "boolean"
+    },
+    id: {
+      type: "string",
+      minLength: PAYMENT_ID_MIN_LENGTH,
+      maxLength: PAYMENT_ID_MAX_LENGTH,
+      pattern: "^[a-zA-Z0-9_-]+$"
+    }
+  },
+  required: ["required"]
+};
+
+// src/payment-identifier/utils.ts
+function generatePaymentId(prefix = "pay_") {
+  const uuid = crypto.randomUUID().replace(/-/g, "");
+  return `${prefix}${uuid}`;
+}
+function isValidPaymentId(id) {
+  if (typeof id !== "string") {
+    return false;
+  }
+  if (id.length < PAYMENT_ID_MIN_LENGTH || id.length > PAYMENT_ID_MAX_LENGTH) {
+    return false;
+  }
+  return PAYMENT_ID_PATTERN.test(id);
+}
+
+// src/payment-identifier/validation.ts
+var import__2 = __toESM(require("ajv/dist/2020.js"));
+function isPaymentIdentifierExtension(extension) {
+  if (!extension || typeof extension !== "object") {
+    return false;
+  }
+  const ext = extension;
+  if (!ext.info || typeof ext.info !== "object") {
+    return false;
+  }
+  const info = ext.info;
+  if (typeof info.required !== "boolean") {
+    return false;
+  }
+  return true;
+}
+function validatePaymentIdentifier(extension) {
+  if (!extension || typeof extension !== "object") {
+    return {
+      valid: false,
+      errors: ["Extension must be an object"]
+    };
+  }
+  const ext = extension;
+  if (!ext.info || typeof ext.info !== "object") {
+    return {
+      valid: false,
+      errors: ["Extension must have an 'info' property"]
+    };
+  }
+  const info = ext.info;
+  if (typeof info.required !== "boolean") {
+    return {
+      valid: false,
+      errors: ["Extension info must have a 'required' boolean property"]
+    };
+  }
+  if (info.id !== void 0 && typeof info.id !== "string") {
+    return {
+      valid: false,
+      errors: ["Extension info 'id' must be a string if provided"]
+    };
+  }
+  if (info.id !== void 0 && !isValidPaymentId(info.id)) {
+    return {
+      valid: false,
+      errors: [
+        `Invalid payment ID format. ID must be 16-128 characters and contain only alphanumeric characters, hyphens, and underscores.`
+      ]
+    };
+  }
+  if (ext.schema) {
+    try {
+      const ajv = new import__2.default({ strict: false, allErrors: true });
+      const validate = ajv.compile(ext.schema);
+      const valid = validate(ext.info);
+      if (!valid && validate.errors) {
+        const errors = validate.errors?.map((err) => {
+          const path = err.instancePath || "(root)";
+          return `${path}: ${err.message}`;
+        }) || ["Unknown validation error"];
+        return { valid: false, errors };
+      }
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          `Schema validation failed: ${error instanceof Error ? error.message : String(error)}`
+        ]
+      };
+    }
+  }
+  return { valid: true };
+}
+function extractPaymentIdentifier(paymentPayload, validate = true) {
+  if (!paymentPayload.extensions) {
+    return null;
+  }
+  const extension = paymentPayload.extensions[PAYMENT_IDENTIFIER];
+  if (!extension || typeof extension !== "object") {
+    return null;
+  }
+  const ext = extension;
+  if (!ext.info || typeof ext.info !== "object") {
+    return null;
+  }
+  const info = ext.info;
+  if (typeof info.id !== "string") {
+    return null;
+  }
+  if (validate && !isValidPaymentId(info.id)) {
+    return null;
+  }
+  return info.id;
+}
+function extractAndValidatePaymentIdentifier(paymentPayload) {
+  if (!paymentPayload.extensions) {
+    return { id: null, validation: { valid: true } };
+  }
+  const extension = paymentPayload.extensions[PAYMENT_IDENTIFIER];
+  if (!extension) {
+    return { id: null, validation: { valid: true } };
+  }
+  const validation = validatePaymentIdentifier(extension);
+  if (!validation.valid) {
+    return { id: null, validation };
+  }
+  const ext = extension;
+  return { id: ext.info.id ?? null, validation: { valid: true } };
+}
+function hasPaymentIdentifier(paymentPayload) {
+  return !!(paymentPayload.extensions && paymentPayload.extensions[PAYMENT_IDENTIFIER]);
+}
+function isPaymentIdentifierRequired(extension) {
+  if (!extension || typeof extension !== "object") {
+    return false;
+  }
+  const ext = extension;
+  if (!ext.info || typeof ext.info !== "object") {
+    return false;
+  }
+  return ext.info.required === true;
+}
+function validatePaymentIdentifierRequirement(paymentPayload, serverRequired) {
+  if (!serverRequired) {
+    return { valid: true };
+  }
+  const id = extractPaymentIdentifier(paymentPayload, false);
+  if (!id) {
+    return {
+      valid: false,
+      errors: ["Server requires a payment identifier but none was provided"]
+    };
+  }
+  if (!isValidPaymentId(id)) {
+    return {
+      valid: false,
+      errors: [
+        `Invalid payment ID format. ID must be 16-128 characters and contain only alphanumeric characters, hyphens, and underscores.`
+      ]
+    };
+  }
+  return { valid: true };
+}
+
+// src/payment-identifier/client.ts
+function appendPaymentIdentifierToExtensions(extensions, id) {
+  const extension = extensions[PAYMENT_IDENTIFIER];
+  if (!isPaymentIdentifierExtension(extension)) {
+    return extensions;
+  }
+  const paymentId = id ?? generatePaymentId();
+  if (!isValidPaymentId(paymentId)) {
+    throw new Error(
+      `Invalid payment ID: "${paymentId}". ID must be 16-128 characters and contain only alphanumeric characters, hyphens, and underscores.`
+    );
+  }
+  extension.info.id = paymentId;
+  return extensions;
+}
+
+// src/payment-identifier/resourceServer.ts
+function declarePaymentIdentifierExtension(required = false) {
+  return {
+    info: { required },
+    schema: paymentIdentifierSchema
+  };
+}
+var paymentIdentifierResourceServerExtension = {
+  key: PAYMENT_IDENTIFIER
+  // No enrichment needed - the declaration is static
+  // Future hooks for idempotency could be added here if needed
+};
+
+// src/eip2612-gas-sponsoring/types.ts
+var EIP2612_GAS_SPONSORING = { key: "eip2612GasSponsoring" };
+
+// src/eip2612-gas-sponsoring/resourceService.ts
+var eip2612GasSponsoringSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    from: {
+      type: "string",
+      pattern: "^0x[a-fA-F0-9]{40}$",
+      description: "The address of the sender."
+    },
+    asset: {
+      type: "string",
+      pattern: "^0x[a-fA-F0-9]{40}$",
+      description: "The address of the ERC-20 token contract."
+    },
+    spender: {
+      type: "string",
+      pattern: "^0x[a-fA-F0-9]{40}$",
+      description: "The address of the spender (Canonical Permit2)."
+    },
+    amount: {
+      type: "string",
+      pattern: "^[0-9]+$",
+      description: "The amount to approve (uint256). Typically MaxUint."
+    },
+    nonce: {
+      type: "string",
+      pattern: "^[0-9]+$",
+      description: "The current nonce of the sender."
+    },
+    deadline: {
+      type: "string",
+      pattern: "^[0-9]+$",
+      description: "The timestamp at which the signature expires."
+    },
+    signature: {
+      type: "string",
+      pattern: "^0x[a-fA-F0-9]+$",
+      description: "The 65-byte concatenated signature (r, s, v) as a hex string."
+    },
+    version: {
+      type: "string",
+      pattern: "^[0-9]+(\\.[0-9]+)*$",
+      description: "Schema version identifier."
+    }
+  },
+  required: ["from", "asset", "spender", "amount", "nonce", "deadline", "signature", "version"]
+};
+function declareEip2612GasSponsoringExtension() {
+  const key = EIP2612_GAS_SPONSORING.key;
+  return {
+    [key]: {
+      info: {
+        description: "The facilitator accepts EIP-2612 gasless Permit to `Permit2` canonical contract.",
+        version: "1"
+      },
+      schema: eip2612GasSponsoringSchema
+    }
+  };
+}
+
+// src/eip2612-gas-sponsoring/facilitator.ts
+function extractEip2612GasSponsoringInfo(paymentPayload) {
+  if (!paymentPayload.extensions) {
+    return null;
+  }
+  const extension = paymentPayload.extensions[EIP2612_GAS_SPONSORING.key];
+  if (!extension?.info) {
+    return null;
+  }
+  const info = extension.info;
+  if (!info.from || !info.asset || !info.spender || !info.amount || !info.nonce || !info.deadline || !info.signature || !info.version) {
+    return null;
+  }
+  return info;
+}
+function validateEip2612GasSponsoringInfo(info) {
+  const addressPattern = /^0x[a-fA-F0-9]{40}$/;
+  const numericPattern = /^[0-9]+$/;
+  const hexPattern = /^0x[a-fA-F0-9]+$/;
+  const versionPattern = /^[0-9]+(\.[0-9]+)*$/;
+  return addressPattern.test(info.from) && addressPattern.test(info.asset) && addressPattern.test(info.spender) && numericPattern.test(info.amount) && numericPattern.test(info.nonce) && numericPattern.test(info.deadline) && hexPattern.test(info.signature) && versionPattern.test(info.version);
+}
+
+// src/erc20-approval-gas-sponsoring/types.ts
+var ERC20_APPROVAL_GAS_SPONSORING = {
+  key: "erc20ApprovalGasSponsoring"
+};
+var ERC20_APPROVAL_GAS_SPONSORING_VERSION = "1";
+function createErc20ApprovalGasSponsoringExtension(signer, signerForNetwork) {
+  return { ...ERC20_APPROVAL_GAS_SPONSORING, signer, signerForNetwork };
+}
+
+// src/erc20-approval-gas-sponsoring/resourceService.ts
+var erc20ApprovalGasSponsoringSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    from: {
+      type: "string",
+      pattern: "^0x[a-fA-F0-9]{40}$",
+      description: "The address of the sender (token owner)."
+    },
+    asset: {
+      type: "string",
+      pattern: "^0x[a-fA-F0-9]{40}$",
+      description: "The address of the ERC-20 token contract."
+    },
+    spender: {
+      type: "string",
+      pattern: "^0x[a-fA-F0-9]{40}$",
+      description: "The address of the spender (Canonical Permit2)."
+    },
+    amount: {
+      type: "string",
+      pattern: "^[0-9]+$",
+      description: "The amount approved (uint256). Always MaxUint256."
+    },
+    signedTransaction: {
+      type: "string",
+      pattern: "^0x[a-fA-F0-9]+$",
+      description: "The RLP-encoded signed EIP-1559 transaction as a hex string."
+    },
+    version: {
+      type: "string",
+      pattern: "^[0-9]+(\\.[0-9]+)*$",
+      description: "Schema version identifier."
+    }
+  },
+  required: ["from", "asset", "spender", "amount", "signedTransaction", "version"]
+};
+function declareErc20ApprovalGasSponsoringExtension() {
+  const key = ERC20_APPROVAL_GAS_SPONSORING.key;
+  return {
+    [key]: {
+      info: {
+        description: "The facilitator broadcasts a pre-signed ERC-20 approve() transaction to grant Permit2 allowance.",
+        version: ERC20_APPROVAL_GAS_SPONSORING_VERSION
+      },
+      schema: erc20ApprovalGasSponsoringSchema
+    }
+  };
+}
+
+// src/erc20-approval-gas-sponsoring/facilitator.ts
+var import__3 = __toESM(require("ajv/dist/2020.js"));
+function extractErc20ApprovalGasSponsoringInfo(paymentPayload) {
+  if (!paymentPayload.extensions) {
+    return null;
+  }
+  const extension = paymentPayload.extensions[ERC20_APPROVAL_GAS_SPONSORING.key];
+  if (!extension?.info) {
+    return null;
+  }
+  const info = extension.info;
+  if (!info.from || !info.asset || !info.spender || !info.amount || !info.signedTransaction || !info.version) {
+    return null;
+  }
+  return info;
+}
+function validateErc20ApprovalGasSponsoringInfo(info) {
+  const ajv = new import__3.default({ strict: false, allErrors: true });
+  const validate = ajv.compile(erc20ApprovalGasSponsoringSchema);
+  return validate(info);
+}
+
+// src/builder-code/types.ts
+var BUILDER_CODE = "builder-code";
+var ERC_8021_MARKER = "80218021802180218021802180218021";
+var SCHEMA_2_ID = 2;
+var BUILDER_CODE_PATTERN = /^[a-z0-9_]{1,32}$/;
+
+// src/builder-code/cbor.ts
+function normalizeServiceCodes(s) {
+  if (typeof s === "string") return [s];
+  if (Array.isArray(s)) return s;
+  return [];
+}
+function encodeCborMap(data) {
+  const entries = [];
+  let mapSize = 0;
+  if (data.a) {
+    mapSize++;
+    entries.push(encodeCborString("a"));
+    entries.push(encodeCborString(data.a));
+  }
+  if (data.w) {
+    mapSize++;
+    entries.push(encodeCborString("w"));
+    entries.push(encodeCborString(data.w));
+  }
+  const serviceCodes = normalizeServiceCodes(data.s);
+  if (serviceCodes.length > 0) {
+    mapSize++;
+    entries.push(encodeCborString("s"));
+    entries.push(encodeCborArray(serviceCodes));
+  }
+  const header = encodeCborMajorType(5, mapSize);
+  const totalLength = header.length + entries.reduce((sum, e) => sum + e.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  result.set(header, offset);
+  offset += header.length;
+  for (const entry of entries) {
+    result.set(entry, offset);
+    offset += entry.length;
+  }
+  return result;
+}
+function encodeCborString(value) {
+  const encoded = new TextEncoder().encode(value);
+  const header = encodeCborMajorType(3, encoded.length);
+  const result = new Uint8Array(header.length + encoded.length);
+  result.set(header, 0);
+  result.set(encoded, header.length);
+  return result;
+}
+function encodeCborArray(values) {
+  const header = encodeCborMajorType(4, values.length);
+  const encodedValues = values.map(encodeCborString);
+  const totalLength = header.length + encodedValues.reduce((sum, e) => sum + e.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  result.set(header, offset);
+  offset += header.length;
+  for (const encoded of encodedValues) {
+    result.set(encoded, offset);
+    offset += encoded.length;
+  }
+  return result;
+}
+function encodeCborMajorType(majorType, value) {
+  const mt = majorType << 5;
+  if (value <= 23) {
+    return new Uint8Array([mt | value]);
+  }
+  if (value <= 255) {
+    return new Uint8Array([mt | 24, value]);
+  }
+  if (value <= 65535) {
+    return new Uint8Array([mt | 25, value >> 8 & 255, value & 255]);
+  }
+  throw new Error(`CBOR value too large: ${value}`);
+}
+function encodeBuilderCodeSuffix(data) {
+  const cborBytes = encodeCborMap(data);
+  const cborLength = cborBytes.length;
+  const lengthHigh = cborLength >> 8 & 255;
+  const lengthLow = cborLength & 255;
+  const suffixBytes = new Uint8Array(cborLength + 2 + 1 + 16);
+  let offset = 0;
+  suffixBytes.set(cborBytes, offset);
+  offset += cborLength;
+  suffixBytes[offset++] = lengthHigh;
+  suffixBytes[offset++] = lengthLow;
+  suffixBytes[offset++] = SCHEMA_2_ID;
+  const markerBytes = hexToBytes(ERC_8021_MARKER);
+  suffixBytes.set(markerBytes, offset);
+  return `0x${bytesToHex(suffixBytes)}`;
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function parseBuilderCodeSuffixFromCalldata(calldata) {
+  const hex = calldata.startsWith("0x") ? calldata.slice(2) : calldata;
+  const markerPos = hex.lastIndexOf(ERC_8021_MARKER.toLowerCase());
+  if (markerPos < 6) {
+    return void 0;
+  }
+  if (parseInt(hex.slice(markerPos - 2, markerPos), 16) !== SCHEMA_2_ID) {
+    return void 0;
+  }
+  const cborLength = parseInt(hex.slice(markerPos - 6, markerPos - 2), 16);
+  const suffixStart = markerPos - 6 - cborLength * 2;
+  if (suffixStart < 0 || suffixStart + (cborLength + 19) * 2 !== hex.length) {
+    return void 0;
+  }
+  const bytes = hexToBytes(hex.slice(suffixStart, markerPos - 6));
+  let o = 0;
+  if (bytes[o] >> 5 !== 5) {
+    return void 0;
+  }
+  const mapInfo = bytes[o++] & 31;
+  const mapSize = mapInfo <= 23 ? mapInfo : mapInfo === 24 ? bytes[o++] : void 0;
+  if (mapSize === void 0) {
+    return void 0;
+  }
+  const result = {};
+  for (let entry = 0; entry < mapSize; entry++) {
+    if (bytes[o] >> 5 !== 3) {
+      return void 0;
+    }
+    const keyInfo = bytes[o++] & 31;
+    const keyLen = keyInfo <= 23 ? keyInfo : keyInfo === 24 ? bytes[o++] : void 0;
+    if (keyLen === void 0) {
+      return void 0;
+    }
+    const key = new TextDecoder().decode(bytes.subarray(o, o + keyLen));
+    o += keyLen;
+    if (key === "a" || key === "w") {
+      if (bytes[o] >> 5 !== 3) {
+        return void 0;
+      }
+      const valueInfo = bytes[o++] & 31;
+      const valueLen = valueInfo <= 23 ? valueInfo : valueInfo === 24 ? bytes[o++] : void 0;
+      if (valueLen === void 0) {
+        return void 0;
+      }
+      result[key] = new TextDecoder().decode(bytes.subarray(o, o + valueLen));
+      o += valueLen;
+      continue;
+    }
+    if (key === "s") {
+      if (bytes[o] >> 5 !== 4) {
+        return void 0;
+      }
+      const arrayInfo = bytes[o++] & 31;
+      const arraySize = arrayInfo <= 23 ? arrayInfo : arrayInfo === 24 ? bytes[o++] : void 0;
+      if (arraySize === void 0) {
+        return void 0;
+      }
+      const codes = [];
+      for (let i = 0; i < arraySize; i++) {
+        if (bytes[o] >> 5 !== 3) {
+          return void 0;
+        }
+        const itemInfo = bytes[o++] & 31;
+        const itemLen = itemInfo <= 23 ? itemInfo : itemInfo === 24 ? bytes[o++] : void 0;
+        if (itemLen === void 0) {
+          return void 0;
+        }
+        codes.push(new TextDecoder().decode(bytes.subarray(o, o + itemLen)));
+        o += itemLen;
+      }
+      if (codes.length > 0) {
+        result.s = codes;
+      }
+      continue;
+    }
+    return void 0;
+  }
+  return result;
+}
+
+// src/builder-code/server.ts
+var BUILDER_CODE_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    a: {
+      type: "string",
+      pattern: "^[a-z0-9_]{1,32}$",
+      description: "App builder code"
+    },
+    w: {
+      type: "string",
+      pattern: "^[a-z0-9_]{1,32}$",
+      description: "Wallet builder code"
+    },
+    s: {
+      type: "array",
+      items: {
+        type: "string",
+        pattern: "^[a-z0-9_]{1,32}$"
+      },
+      description: "Service builder codes"
+    }
+  },
+  additionalProperties: false
+};
+function declareBuilderCodeExtension(appCode) {
+  if (!BUILDER_CODE_PATTERN.test(appCode)) {
+    throw new Error(
+      `Invalid builder code: "${appCode}". Must be 1-32 characters, lowercase alphanumeric and underscores only.`
+    );
+  }
+  return {
+    info: { a: appCode },
+    schema: BUILDER_CODE_SCHEMA
+  };
+}
+var builderCodeResourceServerExtension = {
+  key: BUILDER_CODE
+};
+
+// src/builder-code/client.ts
+var BuilderCodeClientExtension = class {
+  /**
+   * Creates a client extension that attaches the given service code(s) to payments.
+   *
+   * Accepts a single code or an array of codes so layered clients (e.g. an MCP
+   * middleware) can attribute multiple participants. Codes are normalized to an
+   * array and sent as the `s` field.
+   *
+   * @param serviceCodes - Client service code(s) (`s`), each 1-32 lowercase alphanumeric/underscore characters
+   */
+  constructor(serviceCodes) {
+    this.key = BUILDER_CODE;
+    const codes = Array.isArray(serviceCodes) ? serviceCodes : [serviceCodes];
+    for (const code of codes) {
+      if (!BUILDER_CODE_PATTERN.test(code)) {
+        throw new Error(
+          `Invalid builder code: "${code}". Must be 1-32 characters, lowercase alphanumeric and underscores only.`
+        );
+      }
+    }
+    this.serviceCodes = codes;
+  }
+  /**
+   * Attaches this client's service code(s) (`s`).
+   *
+   * @param payload - Payment payload to enrich
+   * @param _ - Server payment requirements; core merges server extension data
+   * @returns Payment payload with builder-code extension data
+   */
+  async enrichPaymentPayload(payload, _) {
+    return {
+      ...payload,
+      extensions: {
+        ...payload.extensions,
+        [BUILDER_CODE]: { info: { s: this.serviceCodes } }
+      }
+    };
+  }
+};
+
+// src/builder-code/facilitator.ts
+function extractClientExtension(extensions) {
+  const info = extensions?.[BUILDER_CODE]?.info;
+  if (typeof info !== "object" || info === null || Array.isArray(info)) return void 0;
+  return info;
+}
+function resolveServiceCodes(raw) {
+  const candidates = typeof raw === "string" ? [raw] : Array.isArray(raw) ? raw : [];
+  return candidates.filter(
+    (v) => typeof v === "string" && BUILDER_CODE_PATTERN.test(v)
+  );
+}
+var BuilderCodeFacilitatorExtension = class {
+  /**
+   * Creates a facilitator extension that encodes builder-code attribution at settlement.
+   *
+   * @param config - Optional facilitator builder-code configuration (wallet code `w`)
+   */
+  constructor(config = {}) {
+    this.key = BUILDER_CODE;
+    if (config.builderCode && !BUILDER_CODE_PATTERN.test(config.builderCode)) {
+      throw new Error(
+        `Invalid builder code: "${config.builderCode}". Must be 1-32 characters, lowercase alphanumeric and underscores only.`
+      );
+    }
+    this.config = config;
+  }
+  /**
+   * Builds the ERC-8021 Schema 2 calldata suffix for a settlement transaction.
+   *
+   * - `a` and `s` are read from the client's payment payload extensions.
+   * - `w` is the facilitator's own code when configured.
+   *
+   * @param ctx - Settlement context with payment-payload extensions
+   * @returns Hex-encoded ERC-8021 builder-code calldata suffix, or undefined when no attribution is present
+   */
+  buildDataSuffix(ctx) {
+    const clientExt = extractClientExtension(ctx.paymentPayload.extensions);
+    const a = typeof clientExt?.a === "string" && BUILDER_CODE_PATTERN.test(clientExt.a) ? clientExt.a : void 0;
+    const s = resolveServiceCodes(clientExt?.s);
+    const data = {
+      ...this.config.builderCode && { w: this.config.builderCode },
+      ...a && { a },
+      ...s.length > 0 && { s }
+    };
+    if (!data.a && !data.w && (!data.s || Array.isArray(data.s) && data.s.length === 0)) {
+      return void 0;
+    }
+    return encodeBuilderCodeSuffix(data);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BAZAAR,
+  BUILDER_CODE,
+  BUILDER_CODE_PATTERN,
+  BUILDER_CODE_SCHEMA,
+  BuilderCodeClientExtension,
+  BuilderCodeFacilitatorExtension,
+  EIP2612_GAS_SPONSORING,
+  ERC20_APPROVAL_GAS_SPONSORING,
+  ERC20_APPROVAL_GAS_SPONSORING_VERSION,
+  ERC_8021_MARKER,
+  InMemorySIWxStorage,
+  OFFER_RECEIPT,
+  OFFER_TYPES,
+  PAYMENT_IDENTIFIER,
+  PAYMENT_ID_MAX_LENGTH,
+  PAYMENT_ID_MIN_LENGTH,
+  PAYMENT_ID_PATTERN,
+  RECEIPT_TYPES,
+  SCHEMA_2_ID,
+  SIGN_IN_WITH_X,
+  SIWxPayloadSchema,
+  SOLANA_DEVNET,
+  SOLANA_MAINNET,
+  SOLANA_TESTNET,
+  appendPaymentIdentifierToExtensions,
+  bazaarResourceServerExtension,
+  buildSIWxSchema,
+  builderCodeResourceServerExtension,
+  canonicalize,
+  checkIfBazaarNeeded,
+  convertNetworkStringToCAIP2,
+  createEIP712OfferReceiptIssuer,
+  createErc20ApprovalGasSponsoringExtension,
+  createJWS,
+  createJWSOfferReceiptIssuer,
+  createOfferDomain,
+  createOfferEIP712,
+  createOfferJWS,
+  createOfferReceiptExtension,
+  createReceiptDomain,
+  createReceiptEIP712,
+  createReceiptJWS,
+  createSIWxClientExtension,
+  createSIWxClientHook,
+  createSIWxMessage,
+  createSIWxPayload,
+  createSIWxRequestHook,
+  createSIWxResourceServerExtension,
+  createSIWxSettleHook,
+  declareBuilderCodeExtension,
+  declareDiscoveryExtension,
+  declareEip2612GasSponsoringExtension,
+  declareErc20ApprovalGasSponsoringExtension,
+  declareOfferReceiptExtension,
+  declarePaymentIdentifierExtension,
+  declareSIWxExtension,
+  decodeBase58,
+  decodeSignedOffers,
+  encodeBase58,
+  encodeBuilderCodeSuffix,
+  encodeSIWxHeader,
+  erc20ApprovalGasSponsoringSchema,
+  extractAndValidatePaymentIdentifier,
+  extractChainIdFromCAIP2,
+  extractDiscoveryInfo,
+  extractDiscoveryInfoFromExtension,
+  extractDiscoveryInfoV1,
+  extractEIP155ChainId,
+  extractEVMChainId,
+  extractEip2612GasSponsoringInfo,
+  extractErc20ApprovalGasSponsoringInfo,
+  extractJWSHeader,
+  extractJWSPayload,
+  extractOfferPayload,
+  extractOffersFromPaymentRequired,
+  extractPaymentIdentifier,
+  extractPublicKeyFromKid,
+  extractReceiptFromResponse,
+  extractReceiptPayload,
+  extractResourceMetadataV1,
+  extractSolanaChainReference,
+  findAcceptsObjectFromSignedOffer,
+  formatSIWEMessage,
+  formatSIWSMessage,
+  generatePaymentId,
+  getCanonicalBytes,
+  getEVMAddress,
+  getSolanaAddress,
+  hasPaymentIdentifier,
+  hashCanonical,
+  hashOfferTypedData,
+  hashReceiptTypedData,
+  isBodyExtensionConfig,
+  isDiscoverableV1,
+  isEIP712SignedOffer,
+  isEIP712SignedReceipt,
+  isEIP712Signer,
+  isEVMSigner,
+  isJWSSignedOffer,
+  isJWSSignedReceipt,
+  isJWSSigner,
+  isMcpExtensionConfig,
+  isPaymentIdentifierExtension,
+  isPaymentIdentifierRequired,
+  isQueryExtensionConfig,
+  isSolanaSigner,
+  isValidIconUrl,
+  isValidPaymentId,
+  isValidRouteTemplate,
+  isValidServiceName,
+  parseBuilderCodeSuffixFromCalldata,
+  parseSIWxHeader,
+  paymentIdentifierResourceServerExtension,
+  paymentIdentifierSchema,
+  prepareOfferForEIP712,
+  prepareReceiptForEIP712,
+  sanitizeResourceServiceMetadata,
+  sanitizeTags,
+  signEVMMessage,
+  signOfferEIP712,
+  signReceiptEIP712,
+  signSolanaMessage,
+  validateAndExtract,
+  validateBazaarRouteExtensions,
+  validateDiscoveryExtension,
+  validateDiscoveryExtensionSpec,
+  validateEip2612GasSponsoringInfo,
+  validateErc20ApprovalGasSponsoringInfo,
+  validatePaymentIdentifier,
+  validatePaymentIdentifierRequirement,
+  validateRouteTemplate,
+  validateSIWxMessage,
+  verifyEVMSignature,
+  verifyOfferSignatureEIP712,
+  verifyOfferSignatureJWS,
+  verifyReceiptMatchesOffer,
+  verifyReceiptSignatureEIP712,
+  verifyReceiptSignatureJWS,
+  verifySIWxSignature,
+  verifySolanaSignature,
+  withBazaar,
+  wrapFetchWithSIWx
+});
+//# sourceMappingURL=index.js.map