@atxp/server 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,9 +1,39 @@
-import { Currency, Network, AuthorizationServerUrl, UrlString, Logger, OAuthDb, OAuthResourceClient, PaymentRequestData, TokenData, RequirePaymentConfig } from '@atxp/common';
-import { Router } from 'express';
+import { Currency, Network, FetchLike, Logger, PaymentRequestData, AuthorizationServerUrl, UrlString, OAuthDb, OAuthResourceClient, TokenData, RequirePaymentConfig } from '@atxp/common';
+import BigNumber from 'bignumber.js';
 import { IncomingMessage, ServerResponse } from 'http';
+import * as oauth from 'oauth4webapi';
 import { IncomingMessage as IncomingMessage$1 } from 'node:http';
 import { JSONRPCRequest } from '@modelcontextprotocol/sdk/types.js';
 
+type FundingAmount = {
+    amount: BigNumber;
+    currency: Currency;
+};
+type PaymentAddress = {
+    destination: string;
+    network: Network;
+};
+interface PaymentDestination {
+    destination(fundingAmount: FundingAmount, buyerAddress: string): Promise<PaymentAddress>;
+}
+declare class ChainPaymentDestination implements PaymentDestination {
+    private readonly address;
+    private readonly network;
+    constructor(address: string, network: Network);
+    destination(_fundingAmount: FundingAmount, _buyerAddress: string): Promise<PaymentAddress>;
+}
+declare class ATXPPaymentDestination implements PaymentDestination {
+    private accountServerURL;
+    private token;
+    private fetchFn;
+    private logger;
+    constructor(connectionString: string, opts?: {
+        fetchFn?: FetchLike;
+        logger?: Logger;
+    });
+    destination(fundingAmount: FundingAmount, buyerAddress: string): Promise<PaymentAddress>;
+}
+
 type McpMethod = 'notifications/cancelled' | 'initialize' | 'ping' | 'notifications/progress' | 'resources/list' | 'resources/templates/list' | 'resources/read' | 'notifications/resources/list_changed' | 'resources/subscribe' | 'resources/unsubscribe' | 'notifications/resources/updated' | 'prompts/list' | 'prompts/get' | 'notifications/prompts/list_changed' | 'tools/list' | 'tools/call' | 'notifications/tools/list_changed' | 'logging/setLevel' | 'notifications/message' | 'sampling/createMessage' | 'elicitation/create' | 'completion/complete' | 'roots/list' | 'notifications/roots/list_changed';
 type McpName = string;
 type McpNamePattern = McpName | '*';
@@ -20,10 +50,9 @@ type PaymentServer = {
     createPaymentRequest: (args: Charge) => Promise<string>;
 };
 type ATXPConfig = {
-    destination: string;
+    paymentDestination: PaymentDestination;
     mountPath: string;
     currency: Currency;
-    network: Network;
     server: AuthorizationServerUrl;
     payeeName: string;
     resource: UrlString | null;
@@ -62,15 +91,6 @@ type ProtectedResourceMetadata = {
     scopes_supported: string[];
 };
 
-type RequiredATXPConfigFields = 'destination';
-type RequiredATXPConfig = Pick<ATXPConfig, RequiredATXPConfigFields>;
-type OptionalATXPConfig = Omit<ATXPConfig, RequiredATXPConfigFields>;
-type ATXPArgs = RequiredATXPConfig & Partial<OptionalATXPConfig>;
-type BuildableATXPConfigFields = 'oAuthDb' | 'oAuthClient' | 'paymentServer' | 'logger';
-declare const DEFAULT_CONFIG: Required<Omit<OptionalATXPConfig, BuildableATXPConfigFields>>;
-declare function buildServerConfig(args: ATXPArgs): ATXPConfig;
-declare function atxpServer(args: ATXPArgs): Router;
-
 declare function getATXPConfig(): ATXPConfig | null;
 declare function getATXPResource(): URL | null;
 declare function atxpAccountId(): string | null;
@@ -96,7 +116,7 @@ declare function createOAuthChallengeResponseCore(tokenCheck: TokenCheck): {
  * Core platform-agnostic MCP request parsing logic
  * Takes parsed JSON and request metadata instead of platform-specific request objects
  */
-declare function parseMcpRequestsCore(config: ATXPConfig, requestUrl: URL, method: string, parsedBody: unknown): any[];
+declare function parseMcpRequestsCore(config: ATXPConfig, requestUrl: URL, method: string, parsedBody: unknown): unknown[];
 
 /**
  * Node.js HTTP implementation of token checking
@@ -109,6 +129,8 @@ declare function checkToken(config: ATXPConfig, resourceURL: URL, req: IncomingM
  * Uses Node.js ServerResponse and delegates to core logic
  */
 declare function sendOAuthChallenge(res: ServerResponse, tokenCheck: TokenCheck): boolean;
+declare function sendProtectedResourceMetadata$1(res: ServerResponse, metadata: ProtectedResourceMetadata | null): boolean;
+declare function sendOAuthMetadata$1(res: ServerResponse, metadata: oauth.AuthorizationServer | null): boolean;
 
 /**
  * Node.js HTTP implementation of MCP request parsing
@@ -128,14 +150,76 @@ declare function checkTokenWebApi(config: ATXPConfig, resourceURL: URL, request:
  * Uses Web API Response and delegates to core logic
  */
 declare function sendOAuthChallengeWebApi(tokenCheck: TokenCheck): Response | null;
+declare function sendProtectedResourceMetadata(metadata: ProtectedResourceMetadata | null): Response | null;
+declare function sendOAuthMetadata(metadata: oauth.AuthorizationServer | null): Response | null;
 
 /**
  * Web API implementation of MCP request parsing for Cloudflare Workers, Deno, etc.
  * Handles Web API Request parsing and delegates to core logic
  */
-declare function parseMcpRequestsWebApi(config: ATXPConfig, request: Request): Promise<any[]>;
+declare function parseMcpRequestsWebApi(config: ATXPConfig, request: Request): Promise<JSONRPCRequest[]>;
 
 declare function requirePayment(paymentConfig: RequirePaymentConfig): Promise<void>;
 
-export { DEFAULT_CONFIG, TokenProblem, atxpAccountId, atxpServer, buildServerConfig, checkToken, checkTokenCore, checkTokenWebApi, createOAuthChallengeResponseCore, getATXPConfig, getATXPResource, parseBody, parseMcpRequests, parseMcpRequestsCore, parseMcpRequestsWebApi, requirePayment, sendOAuthChallenge, sendOAuthChallengeWebApi, withATXPContext };
-export type { ATXPArgs, ATXPConfig, Charge, ChargeResponse, McpMethod, McpName, McpNamePattern, McpOperation, McpOperationPattern, PaymentServer, ProtectedResourceMetadata, RefundErrors, TokenCheck, TokenCheckFail, TokenCheckPass };
+type RequiredATXPConfigFields = 'paymentDestination';
+type RequiredATXPConfig = Pick<ATXPConfig, RequiredATXPConfigFields>;
+type OptionalATXPConfig = Omit<ATXPConfig, RequiredATXPConfigFields>;
+type ATXPArgs = RequiredATXPConfig & Partial<OptionalATXPConfig>;
+type BuildableATXPConfigFields = 'oAuthDb' | 'oAuthClient' | 'paymentServer' | 'logger';
+declare const DEFAULT_CONFIG: Required<Omit<OptionalATXPConfig, BuildableATXPConfigFields>>;
+declare function buildServerConfig(args: ATXPArgs): ATXPConfig;
+
+declare function getResource(config: ATXPConfig, requestUrl: URL, headers?: Record<string, string | string[] | undefined>): URL;
+
+/**
+ * ATXP Payment Server implementation
+ *
+ * This class handles payment operations with the ATXP authorization server.
+ *
+ * @example
+ * ```typescript
+ * const paymentServer = new ATXPPaymentServer(
+ *   'https://auth.atxp.ai',
+ *   logger
+ * );
+ * ```
+ */
+declare class ATXPPaymentServer implements PaymentServer {
+    private readonly server;
+    private readonly logger;
+    private readonly fetchFn;
+    constructor(server: AuthorizationServerUrl, logger: Logger, fetchFn?: FetchLike);
+    charge: ({ source, destination, network, currency, amount }: {
+        source: string;
+        destination: string;
+        network: Network;
+        currency: Currency;
+        amount: BigNumber;
+    }) => Promise<ChargeResponse>;
+    createPaymentRequest: (charge: Charge) => Promise<string>;
+    /**
+     * Makes authenticated requests to the ATXP authorization server
+     *
+     * @param method - HTTP method ('GET' or 'POST')
+     * @param path - API endpoint path
+     * @param body - Request body (for POST requests)
+     * @returns Promise<Response> - The HTTP response from the server
+     *
+     * @example
+     * ```typescript
+     * const response = await paymentServer.makeRequest('POST', '/charge', {
+     *   source: 'user123',
+     *   destination: 'merchant456',
+     *   amount: new BigNumber('0.01')
+     * });
+     * ```
+     */
+    protected makeRequest: (method: "GET" | "POST", path: string, body: unknown) => Promise<Response>;
+}
+
+declare function getOAuthMetadata(config: ATXPConfig, requestUrl: URL): Promise<oauth.AuthorizationServer | null>;
+
+declare function getProtectedResourceMetadata(config: ATXPConfig, requestUrl: URL, headers?: Record<string, string | string[] | undefined>): ProtectedResourceMetadata | null;
+
+export { ATXPPaymentDestination, ATXPPaymentServer, ChainPaymentDestination, DEFAULT_CONFIG, TokenProblem, atxpAccountId, buildServerConfig, checkTokenCore, checkToken as checkTokenNode, checkTokenWebApi, createOAuthChallengeResponseCore, getATXPConfig, getATXPResource, getOAuthMetadata, getProtectedResourceMetadata, getResource, parseBody as parseBodyNode, parseMcpRequestsCore, parseMcpRequests as parseMcpRequestsNode, parseMcpRequestsWebApi, requirePayment, sendOAuthChallenge, sendOAuthChallengeWebApi, sendOAuthMetadata$1 as sendOAuthMetadataNode, sendOAuthMetadata as sendOAuthMetadataWebApi, sendProtectedResourceMetadata$1 as sendProtectedResourceMetadataNode, sendProtectedResourceMetadata as sendProtectedResourceMetadataWebApi, withATXPContext };
+export type { ATXPArgs, ATXPConfig, Charge, ChargeResponse, FundingAmount, McpMethod, McpName, McpNamePattern, McpOperation, McpOperationPattern, PaymentAddress, PaymentDestination, PaymentServer, ProtectedResourceMetadata, RefundErrors, TokenCheck, TokenCheckFail, TokenCheckPass };