mcpay/dist/x402/index.d.ts

SDK and CLI for MCPay functionality - MCP servers with payment capabilities

import { Account, Address, Chain, Client, Hex, LocalAccount, PublicActions, RpcSchema, Transport, WalletActions } from "viem";
import { type PaymentRequirements as BasePaymentRequirements, type Network } from "x402/types";
import { z } from "zod";
export type SignerWallet<chain extends Chain = Chain, transport extends Transport = Transport, account extends Account = Account> = Client<transport, chain, account, RpcSchema, PublicActions<transport, chain, account> & WalletActions<chain, account>>;
export declare const authorizationTypes: {
    TransferWithAuthorization: {
        name: string;
        type: string;
    }[];
};
export declare const authorizationPrimaryType = "TransferWithAuthorization";
export declare const NetworkSchema: z.ZodEnum<["base-sepolia", "base", "avalanche-fuji", "avalanche", "iotex", "sei-testnet"]>;
export declare const SupportedEVMNetworks: SupportedNetwork[];
export declare const EvmNetworkToChainId: Map<"base-sepolia" | "base" | "avalanche-fuji" | "avalanche" | "iotex" | "sei-testnet", number>;
export declare const ChainIdToNetwork: Record<number, Network>;
export declare const schemes: readonly ["exact"];
export declare const ExactEvmPayloadAuthorizationSchema: z.ZodObject<{
    from: z.ZodString;
    to: z.ZodString;
    value: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
    validAfter: z.ZodEffects<z.ZodString, string, string>;
    validBefore: z.ZodEffects<z.ZodString, string, string>;
    nonce: z.ZodString;
}, "strip", z.ZodTypeAny, {
    from: string;
    nonce: string;
    to: string;
    value: string;
    validAfter: string;
    validBefore: string;
}, {
    from: string;
    nonce: string;
    to: string;
    value: string;
    validAfter: string;
    validBefore: string;
}>;
export type ExactEvmPayloadAuthorization = z.infer<typeof ExactEvmPayloadAuthorizationSchema>;
export declare const ExactEvmPayloadSchema: z.ZodObject<{
    signature: z.ZodUnion<[z.ZodString, z.ZodString]>;
    authorization: z.ZodObject<{
        from: z.ZodString;
        to: z.ZodString;
        value: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
        validAfter: z.ZodEffects<z.ZodString, string, string>;
        validBefore: z.ZodEffects<z.ZodString, string, string>;
        nonce: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        from: string;
        nonce: string;
        to: string;
        value: string;
        validAfter: string;
        validBefore: string;
    }, {
        from: string;
        nonce: string;
        to: string;
        value: string;
        validAfter: string;
        validBefore: string;
    }>;
}, "strip", z.ZodTypeAny, {
    authorization: {
        from: string;
        nonce: string;
        to: string;
        value: string;
        validAfter: string;
        validBefore: string;
    };
    signature: string;
}, {
    authorization: {
        from: string;
        nonce: string;
        to: string;
        value: string;
        validAfter: string;
        validBefore: string;
    };
    signature: string;
}>;
export type ExactEvmPayload = z.infer<typeof ExactEvmPayloadSchema>;
export declare const PaymentPayloadSchema: z.ZodObject<{
    x402Version: z.ZodEffects<z.ZodNumber, number, number>;
    scheme: z.ZodEnum<["exact"]>;
    network: z.ZodEnum<["base-sepolia", "base", "avalanche-fuji", "avalanche", "iotex", "sei-testnet"]>;
    payload: z.ZodObject<{
        signature: z.ZodUnion<[z.ZodString, z.ZodString]>;
        authorization: z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            value: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
            validAfter: z.ZodEffects<z.ZodString, string, string>;
            validBefore: z.ZodEffects<z.ZodString, string, string>;
            nonce: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            from: string;
            nonce: string;
            to: string;
            value: string;
            validAfter: string;
            validBefore: string;
        }, {
            from: string;
            nonce: string;
            to: string;
            value: string;
            validAfter: string;
            validBefore: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        authorization: {
            from: string;
            nonce: string;
            to: string;
            value: string;
            validAfter: string;
            validBefore: string;
        };
        signature: string;
    }, {
        authorization: {
            from: string;
            nonce: string;
            to: string;
            value: string;
            validAfter: string;
            validBefore: string;
        };
        signature: string;
    }>;
}, "strip", z.ZodTypeAny, {
    scheme: "exact";
    x402Version: number;
    network: "base-sepolia" | "base" | "avalanche-fuji" | "avalanche" | "iotex" | "sei-testnet";
    payload: {
        authorization: {
            from: string;
            nonce: string;
            to: string;
            value: string;
            validAfter: string;
            validBefore: string;
        };
        signature: string;
    };
}, {
    scheme: "exact";
    x402Version: number;
    network: "base-sepolia" | "base" | "avalanche-fuji" | "avalanche" | "iotex" | "sei-testnet";
    payload: {
        authorization: {
            from: string;
            nonce: string;
            to: string;
            value: string;
            validAfter: string;
            validBefore: string;
        };
        signature: string;
    };
}>;
export type PaymentPayload = z.infer<typeof PaymentPayloadSchema>;
export type UnsignedPaymentPayload = Omit<PaymentPayload, "payload"> & {
    payload: Omit<ExactEvmPayload, "signature"> & {
        signature: undefined;
    };
};
export declare function isSignerWallet<TChain extends Chain = Chain, TTransport extends Transport = Transport, TAccount extends Account = Account>(wallet: SignerWallet<TChain, TTransport, TAccount> | LocalAccount): wallet is SignerWallet<TChain, TTransport, TAccount>;
export declare function isAccount<TChain extends Chain = Chain, TTransport extends Transport = Transport, TAccount extends Account = Account>(wallet: SignerWallet<TChain, TTransport, TAccount> | LocalAccount): wallet is LocalAccount;
export declare function createNonce(): Hex;
export declare function preparePaymentHeader(from: Address, x402Version: number, paymentRequirements: ExtendedPaymentRequirements): UnsignedPaymentPayload;
export declare function createPayment<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, x402Version: number, paymentRequirements: ExtendedPaymentRequirements): Promise<PaymentPayload>;
export declare function signAuthorization<transport extends Transport, chain extends Chain>(walletClient: SignerWallet<chain, transport> | LocalAccount, { from, to, value, validAfter, validBefore, nonce }: ExactEvmPayloadAuthorization, { asset, network, extra }: ExtendedPaymentRequirements): Promise<{
    signature: Hex;
}>;
/**
 * Encodes a string to base64 format
 *
 * @param data - The string to be encoded to base64
 * @returns The base64 encoded string
 */
export declare function safeBase64Encode(data: string): string;
/**
 * Decodes a base64 string back to its original format
 *
 * @param data - The base64 encoded string to be decoded
 * @returns The decoded string in UTF-8 format
 */
export declare function safeBase64Decode(data: string): string;
export declare function encodePayment(payment: PaymentPayload): string;
export declare function createPaymentHeaderExactEVM(client: SignerWallet | LocalAccount, x402Version: number, paymentRequirements: ExtendedPaymentRequirements): Promise<string>;
export declare function signPaymentHeader<transport extends Transport, chain extends Chain>(client: SignerWallet<chain, transport> | LocalAccount, paymentRequirements: ExtendedPaymentRequirements, unsignedPaymentHeader: UnsignedPaymentPayload): Promise<PaymentPayload>;
export declare function createPaymentHeader(client: SignerWallet | LocalAccount, x402Version: number, paymentRequirements: ExtendedPaymentRequirements): Promise<string>;
/**
* Gets the default asset (USDC) for the given network
*
* @param network - The network to get the default asset for
* @returns The default asset
*/
export declare function getDefaultAsset(network: SupportedNetwork): {
    address: `0x${string}`;
    decimals: number;
    eip712: {
        name: string;
        version: string;
    };
};
export declare function getUsdcAddressForChain(chainId: number): Address;
export declare function getNetworkId(network: SupportedNetwork): number;
export declare const config: Record<string, ChainConfig>;
export type ChainConfig = {
    usdcAddress: Address;
    usdcName: string;
};
export declare const SupportedNetworkSchema: z.ZodEnum<["base-sepolia", "base", "avalanche-fuji", "avalanche", "iotex", "sei-testnet"]>;
export type SupportedNetwork = z.infer<typeof SupportedNetworkSchema>;
export declare const ExtendedPaymentRequirementsSchema: z.ZodObject<{
    scheme: z.ZodEnum<["exact"]>;
    network: z.ZodEnum<["base-sepolia", "base", "avalanche-fuji", "avalanche", "iotex", "sei-testnet"]>;
    maxAmountRequired: z.ZodString;
    resource: z.ZodString;
    description: z.ZodString;
    mimeType: z.ZodString;
    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    payTo: z.ZodString;
    maxTimeoutSeconds: z.ZodNumber;
    asset: z.ZodString;
    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    scheme: "exact";
    network: "base-sepolia" | "base" | "avalanche-fuji" | "avalanche" | "iotex" | "sei-testnet";
    maxAmountRequired: string;
    resource: string;
    description: string;
    mimeType: string;
    payTo: string;
    maxTimeoutSeconds: number;
    asset: string;
    outputSchema?: Record<string, any> | undefined;
    extra?: Record<string, any> | undefined;
}, {
    scheme: "exact";
    network: "base-sepolia" | "base" | "avalanche-fuji" | "avalanche" | "iotex" | "sei-testnet";
    maxAmountRequired: string;
    resource: string;
    description: string;
    mimeType: string;
    payTo: string;
    maxTimeoutSeconds: number;
    asset: string;
    outputSchema?: Record<string, any> | undefined;
    extra?: Record<string, any> | undefined;
}>;
export type ExtendedPaymentRequirements = z.infer<typeof ExtendedPaymentRequirementsSchema>;
export type SupportedPaymentRequirements = Omit<BasePaymentRequirements, 'network'> & {
    network: SupportedNetwork;
};
export declare function selectPaymentRequirements(paymentRequirements: ExtendedPaymentRequirements[], network?: Network, scheme?: "exact"): ExtendedPaymentRequirements;
/**
 * Selector for payment requirements.
 *
 * @param paymentRequirements - The payment requirements to select from.
 * @param network - The network to check against. If not provided, the network will not be checked.
 * @param scheme - The scheme to check against. If not provided, the scheme will not be checked.
 * @returns The payment requirement that is the most appropriate for the user.
 */
export type PaymentRequirementsSelector = (paymentRequirements: ExtendedPaymentRequirements[], network?: Network, scheme?: "exact") => ExtendedPaymentRequirements;
//# sourceMappingURL=index.d.ts.map