@atxp/client 0.2.22 → 0.4.0

package/dist/index.d.ts

@@ -1,10 +1,250 @@
-export * from './atxpClient.js';
-export * from './oAuth.js';
-export * from './atxpFetcher.js';
-export * from './solanaPaymentMaker.js';
-export * from './solanaAccount.js';
-export * from './atxpAccount.js';
-export * from './baseAccount.js';
-export * from './basePaymentMaker.js';
-export * from './types.js';
-//# sourceMappingURL=index.d.ts.map
+import { Currency, AuthorizationServerUrl, Network, OAuthDb, FetchLike, Logger, OAuthResourceClient, ClientCredentials, PKCEValues, AccessToken, PaymentRequestData } from '@atxp/common';
+import { ClientOptions, Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { Implementation, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import * as oauth from 'oauth4webapi';
+import { ValidateTransferError as ValidateTransferError$1 } from '@solana/pay';
+import BigNumber$1 from 'bignumber.js';
+import { WalletClient, PublicActions } from 'viem';
+
+type Hex = `0x${string}`;
+type AccountPrefix = Network;
+type AccountIdString = `${AccountPrefix}${string}`;
+type Account = {
+    accountId: string;
+    paymentMakers: {
+        [key: string]: PaymentMaker;
+    };
+};
+type ProspectivePayment = {
+    accountId: string;
+    resourceUrl: string;
+    resourceName: string;
+    network: Network;
+    currency: Currency;
+    amount: BigNumber;
+    iss: string;
+};
+type ClientConfig = {
+    mcpServer: string;
+    account: Account;
+    allowedAuthorizationServers: AuthorizationServerUrl[];
+    approvePayment: (payment: ProspectivePayment) => Promise<boolean>;
+    oAuthDb: OAuthDb;
+    fetchFn: FetchLike;
+    oAuthChannelFetch: FetchLike;
+    allowHttp: boolean;
+    logger: Logger;
+    clientInfo: Implementation;
+    clientOptions: ClientOptions;
+    onAuthorize: (args: {
+        authorizationServer: AuthorizationServerUrl;
+        userId: string;
+    }) => Promise<void>;
+    onAuthorizeFailure: (args: {
+        authorizationServer: AuthorizationServerUrl;
+        userId: string;
+        error: Error;
+    }) => Promise<void>;
+    onPayment: (args: {
+        payment: ProspectivePayment;
+    }) => Promise<void>;
+    onPaymentFailure: (args: {
+        payment: ProspectivePayment;
+        error: Error;
+    }) => Promise<void>;
+};
+declare class InsufficientFundsError extends Error {
+    readonly currency: Currency;
+    readonly required: BigNumber;
+    readonly available?: BigNumber | undefined;
+    readonly network?: string | undefined;
+    constructor(currency: Currency, required: BigNumber, available?: BigNumber | undefined, network?: string | undefined);
+}
+declare class PaymentNetworkError extends Error {
+    readonly originalError?: Error | undefined;
+    constructor(message: string, originalError?: Error | undefined);
+}
+interface PaymentMaker {
+    makePayment: (amount: BigNumber, currency: Currency, receiver: string, memo: string) => Promise<string>;
+    generateJWT: (params: {
+        paymentRequestId: string;
+        codeChallenge: string;
+    }) => Promise<string>;
+}
+
+type RequiredClientConfigFields = 'mcpServer' | 'account';
+type RequiredClientConfig = Pick<ClientConfig, RequiredClientConfigFields>;
+type OptionalClientConfig = Omit<ClientConfig, RequiredClientConfigFields>;
+type ClientArgs = RequiredClientConfig & Partial<OptionalClientConfig>;
+type BuildableClientConfigFields = 'oAuthDb' | 'logger';
+declare const DEFAULT_CLIENT_CONFIG: Required<Omit<OptionalClientConfig, BuildableClientConfigFields>>;
+declare function buildClientConfig(args: ClientArgs): ClientConfig;
+declare function buildStreamableTransport(args: ClientArgs): StreamableHTTPClientTransport;
+declare function atxpClient(args: ClientArgs): Promise<Client>;
+
+declare class OAuthAuthenticationRequiredError extends Error {
+    readonly url: string;
+    readonly resourceServerUrl: string;
+    readonly idempotencyKey: string;
+    constructor(url: string, resourceServerUrl: string, idempotencyKey: string);
+    static create(url: string, resourceServerUrl: string, token?: string): Promise<OAuthAuthenticationRequiredError>;
+}
+interface OAuthClientConfig {
+    userId: string;
+    db: OAuthDb;
+    callbackUrl: string;
+    isPublic: boolean;
+    fetchFn?: FetchLike;
+    sideChannelFetch?: FetchLike;
+    strict?: boolean;
+    allowInsecureRequests?: boolean;
+    clientName?: string;
+    logger?: Logger;
+}
+declare class OAuthClient extends OAuthResourceClient {
+    protected db: OAuthDb;
+    protected userId: string;
+    protected fetchFn: FetchLike;
+    constructor({ userId, db, callbackUrl, clientName, isPublic, fetchFn, sideChannelFetch, strict, allowInsecureRequests, logger }: OAuthClientConfig);
+    protected extractResourceUrl: (response: Response) => string | null;
+    fetch: FetchLike;
+    makeAuthorizationUrl: (url: string, resourceUrl: string) => Promise<URL>;
+    handleCallback: (url: string) => Promise<void>;
+    getRegistrationMetadata: () => Promise<Partial<oauth.OmitSymbolProperties<oauth.Client>>>;
+    protected generatePKCE: (url: string, resourceUrl: string) => Promise<{
+        codeVerifier: string;
+        codeChallenge: string;
+        state: string;
+    }>;
+    protected makeTokenRequestAndClient: (authorizationServer: oauth.AuthorizationServer, credentials: ClientCredentials, codeVerifier: string, authResponse: URLSearchParams) => Promise<[Response, oauth.Client]>;
+    protected exchangeCodeForToken: (authResponse: URLSearchParams, pkceValues: PKCEValues, authorizationServer: oauth.AuthorizationServer) => Promise<string>;
+    protected getAccessToken: (url: string) => Promise<AccessToken | null>;
+    protected tryRefreshToken: (url: string) => Promise<AccessToken | null>;
+    protected _doFetch: FetchLike;
+}
+
+interface ATXPFetcherConfig {
+    accountId: string;
+    db: OAuthDb;
+    paymentMakers: {
+        [key: string]: PaymentMaker;
+    };
+    fetchFn?: FetchLike;
+    sideChannelFetch?: FetchLike;
+    strict?: boolean;
+    allowInsecureRequests?: boolean;
+    allowedAuthorizationServers?: AuthorizationServerUrl[];
+    approvePayment?: (payment: ProspectivePayment) => Promise<boolean>;
+    logger?: Logger;
+    onAuthorize?: (args: {
+        authorizationServer: AuthorizationServerUrl;
+        userId: string;
+    }) => Promise<void>;
+    onAuthorizeFailure?: (args: {
+        authorizationServer: AuthorizationServerUrl;
+        userId: string;
+        error: Error;
+    }) => Promise<void>;
+    onPayment?: (args: {
+        payment: ProspectivePayment;
+    }) => Promise<void>;
+    onPaymentFailure?: (args: {
+        payment: ProspectivePayment;
+        error: Error;
+    }) => Promise<void>;
+}
+declare function atxpFetch(config: ATXPFetcherConfig): FetchLike;
+declare class ATXPFetcher {
+    protected oauthClient: OAuthClient;
+    protected paymentMakers: Map<string, PaymentMaker>;
+    protected sideChannelFetch: FetchLike;
+    protected db: OAuthDb;
+    protected accountId: string;
+    protected allowedAuthorizationServers: AuthorizationServerUrl[];
+    protected approvePayment: (payment: ProspectivePayment) => Promise<boolean>;
+    protected logger: Logger;
+    protected onAuthorize: (args: {
+        authorizationServer: AuthorizationServerUrl;
+        userId: string;
+    }) => Promise<void>;
+    protected onAuthorizeFailure: (args: {
+        authorizationServer: AuthorizationServerUrl;
+        userId: string;
+        error: Error;
+    }) => Promise<void>;
+    protected onPayment: (args: {
+        payment: ProspectivePayment;
+    }) => Promise<void>;
+    protected onPaymentFailure: (args: {
+        payment: ProspectivePayment;
+        error: Error;
+    }) => Promise<void>;
+    constructor({ accountId, db, paymentMakers, fetchFn, sideChannelFetch, strict, allowInsecureRequests, allowedAuthorizationServers, approvePayment, logger, onAuthorize, onAuthorizeFailure, onPayment, onPaymentFailure }: ATXPFetcherConfig);
+    private defaultPaymentFailureHandler;
+    protected handlePaymentRequestError: (paymentRequestError: McpError) => Promise<boolean>;
+    protected getPaymentRequestData: (paymentRequestUrl: string) => Promise<PaymentRequestData | null>;
+    protected isAllowedAuthServer: (url: string | URL) => boolean;
+    protected makeAuthRequestWithPaymentMaker: (authorizationUrl: URL, paymentMaker: PaymentMaker) => Promise<string>;
+    protected authToService: (error: OAuthAuthenticationRequiredError) => Promise<void>;
+    protected exchangeToken: (myToken: AccessToken, newResourceUrl: string) => Promise<AccessToken>;
+    protected checkForATXPResponse: (response: Response) => Promise<void>;
+    fetch: FetchLike;
+}
+
+declare const ValidateTransferError: typeof ValidateTransferError$1;
+declare class SolanaPaymentMaker implements PaymentMaker {
+    private connection;
+    private source;
+    private logger;
+    constructor(solanaEndpoint: string, sourceSecretKey: string, logger?: Logger);
+    generateJWT: ({ paymentRequestId, codeChallenge }: {
+        paymentRequestId: string;
+        codeChallenge: string;
+    }) => Promise<string>;
+    makePayment: (amount: BigNumber$1, currency: Currency, receiver: string, memo: string) => Promise<string>;
+}
+
+type ExtendedWalletClient = WalletClient & PublicActions;
+declare class BasePaymentMaker implements PaymentMaker {
+    protected signingClient: ExtendedWalletClient;
+    protected logger: Logger;
+    constructor(baseRPCUrl: string, walletClient: WalletClient, logger?: Logger);
+    generateJWT({ paymentRequestId, codeChallenge }: {
+        paymentRequestId: string;
+        codeChallenge: string;
+    }): Promise<string>;
+    makePayment(amount: BigNumber, currency: Currency, receiver: string): Promise<string>;
+}
+
+declare class SolanaAccount implements Account {
+    accountId: string;
+    paymentMakers: {
+        [key: string]: PaymentMaker;
+    };
+    constructor(solanaEndpoint: string, sourceSecretKey: string);
+}
+
+declare class ATXPAccount implements Account {
+    accountId: string;
+    paymentMakers: {
+        [key: string]: PaymentMaker;
+    };
+    constructor(connectionString: string, opts?: {
+        fetchFn?: FetchLike;
+        network?: Network;
+    });
+}
+
+declare const USDC_CONTRACT_ADDRESS_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+
+declare class BaseAccount implements Account {
+    accountId: string;
+    paymentMakers: {
+        [key: string]: PaymentMaker;
+    };
+    constructor(baseRPCUrl: string, sourceSecretKey: string);
+}
+
+export { ATXPAccount, ATXPFetcher, BaseAccount, BasePaymentMaker, DEFAULT_CLIENT_CONFIG, InsufficientFundsError, OAuthAuthenticationRequiredError, OAuthClient, PaymentNetworkError, SolanaAccount, SolanaPaymentMaker, USDC_CONTRACT_ADDRESS_BASE, ValidateTransferError, atxpClient, atxpFetch, buildClientConfig, buildStreamableTransport };
+export type { ATXPFetcherConfig, Account, AccountIdString, ClientArgs, ClientConfig, Hex, OAuthClientConfig, PaymentMaker, ProspectivePayment };