mppx 0.8.15 → 0.8.18

package/dist/stripe/server/Charge.d.ts

@@ -35,13 +35,13 @@ export declare function charge<const parameters extends charge.Parameters>(param
     readonly name: "stripe";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniObject<{
+        credential: {
+            payload: z.ZodMiniObject<{
                 externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 spt: z.ZodMiniString<string>;
             }, z.core.$strip>;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        request: z.ZodMiniPipe<z.ZodMiniObject<{
             amount: z.ZodMiniString<string>;
             currency: z.ZodMiniString<string>;
             decimals: z.ZodMiniNumber<number>;
@@ -52,25 +52,25 @@ export declare function charge<const parameters extends charge.Parameters>(param
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
+            currency: string;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            recipient?: string | undefined;
             amount: string;
             methodDetails: {
-                metadata?: Record<string, string> | undefined;
                 networkId: string;
                 paymentMethodTypes: string[];
+                metadata?: Record<string, string> | undefined;
             };
-            currency: string;
-            description?: string | undefined;
-            externalId?: string | undefined;
-            recipient?: string | undefined;
         }, {
             amount: string;
             currency: string;
             decimals: number;
-            networkId: string;
-            paymentMethodTypes: string[];
             description?: string | undefined;
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
+            networkId: string;
+            paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;
     };
@@ -92,7 +92,7 @@ export declare namespace charge {
         metadata?: Record<string, string> | undefined;
         /** Optional server-side Stripe Connect settlement policy. Not included in MPP challenges. */
         connect?: ConnectSettlement | ResolveConnectSettlement | undefined;
-    } & Defaults & OneOf<{
+    } & Method.ComposableHooks<typeof Methods.charge> & Defaults & OneOf<{
         /** Pre-configured Stripe SDK instance. Any object matching the duck-typed `StripeClient` shape works. */
         client: StripeClient;
     } | {

package/dist/stripe/server/Charge.js

@@ -4,6 +4,47 @@ import * as Method from '../../Method.js';
 import { stripePreviewVersion } from '../internal/constants.js';
 import * as Methods from '../Methods.js';
 import { html as htmlContent } from './internal/html.gen.js';
+/**
+ * Stripe's general minimum charge amounts in each currency's smallest unit.
+ * Payment methods with lower provider-specific exceptions remain conservatively
+ * subject to the general minimum.
+ *
+ * @see https://docs.stripe.com/currencies#minimum-and-maximum-charge-amounts
+ */
+const minimumChargeAmountByCurrency = {
+    aed: 200n,
+    ars: 50n,
+    aud: 50n,
+    bgn: 100n,
+    brl: 50n,
+    cad: 50n,
+    chf: 50n,
+    cop: 50n,
+    czk: 1500n,
+    dkk: 250n,
+    eur: 50n,
+    gbp: 30n,
+    hkd: 400n,
+    huf: 17500n,
+    idr: 50n,
+    ils: 50n,
+    inr: 50n,
+    jpy: 50n,
+    krw: 50n,
+    mxn: 1000n,
+    myr: 200n,
+    nok: 300n,
+    nzd: 50n,
+    php: 50n,
+    pln: 200n,
+    ron: 200n,
+    rub: 50n,
+    sek: 300n,
+    sgd: 50n,
+    thb: 1000n,
+    usd: 50n,
+    zar: 50n,
+};
 /**
  * Creates a Stripe charge method intent for usage on the server.
  *
@@ -30,7 +71,7 @@ import { html as htmlContent } from './internal/html.gen.js';
  * ```
  */
 export function charge(parameters) {
-    const { amount, currency, decimals, description, externalId, html: { text: htmlText, theme: htmlTheme, ...htmlConfig } = {}, metadata, networkId, paymentMethodTypes, } = parameters;
+    const { amount, canOffer, onPaymentSuccess, currency, decimals, description, externalId, html: { text: htmlText, theme: htmlTheme, ...htmlConfig } = {}, metadata, networkId, paymentMethodTypes, } = parameters;
     const client = 'client' in parameters ? parameters.client : undefined;
     const connect = parameters.connect;
     const secretKey = 'secretKey' in parameters ? parameters.secretKey : undefined;
@@ -67,6 +108,13 @@ export function charge(parameters) {
                 theme: htmlTheme,
             }
             : undefined,
+        async canOffer(context) {
+            const minimum = minimumChargeAmountByCurrency[context.request.currency.toLowerCase()];
+            if (minimum !== undefined && BigInt(context.request.amount) < minimum)
+                return false;
+            return (await canOffer?.(context)) ?? true;
+        },
+        onPaymentSuccess,
         async verify({ credential, envelope, request }) {
             const { challenge } = credential;
             const resolvedRequest = (() => {
@@ -159,7 +207,7 @@ async function createWithClient(parameters) {
         };
         const paymentIntentOptions = {
             apiVersion: stripePreviewVersion,
-            idempotencyKey: `mppx_${challenge.id}_${spt}`,
+            idempotencyKey: `mpp_${challenge.id}_${spt}`,
             ...(settlement?.stripeAccount !== undefined && { stripeAccount: settlement.stripeAccount }),
         };
         const result = await client.paymentIntents.create(paymentIntentParams, paymentIntentOptions);
@@ -202,7 +250,7 @@ async function createWithSecretKey(parameters) {
     const headers = {
         Authorization: `Basic ${btoa(`${secretKey}:`)}`,
         'Content-Type': 'application/x-www-form-urlencoded',
-        'Idempotency-Key': `mppx_${challenge.id}_${spt}`,
+        'Idempotency-Key': `mpp_${challenge.id}_${spt}`,
         'Stripe-Version': stripePreviewVersion,
         ...(settlement?.stripeAccount !== undefined && { 'Stripe-Account': settlement.stripeAccount }),
     };
@@ -236,8 +284,6 @@ function buildAnalytics(parameters) {
     const { credential } = parameters;
     const { challenge } = credential;
     return {
-        mpp_version: '1',
-        mpp_is_mpp: 'true',
         mpp_intent: challenge.intent,
         mpp_challenge_id: challenge.id,
         mpp_server_id: challenge.realm,

package/dist/stripe/server/Methods.d.ts

@@ -1,63 +1,152 @@
+import { charge as evmCharge } from '../../evm/server/Charge.js';
+import type * as Method from '../../Method.js';
+import { charge as tempoCharge } from '../../tempo/server/Charge.js';
+import { session as tempoSession } from '../../tempo/session/server/Session.js';
+import type { StripeClient } from '../internal/types.js';
 import { charge as charge_ } from './Charge.js';
+import { findOrCreateDepositAddress as _findOrCreateDepositAddress } from './internal/deposit-address.js';
+import { type ConnectConfig } from './internal/request.js';
+export declare namespace stripe {
+    type Network = 'tempo' | 'base' | 'solana';
+    type DepositAddress<N extends Network = Network> = string & {
+        readonly __brand: 'StripeDepositAddress';
+        readonly __network: N;
+    };
+    type Parameters = {
+        client: StripeClient;
+        networkId: string;
+        livemode: boolean;
+        connect?: ConnectConfig;
+        depositAddresses?: Partial<Record<Network, string>> | ((network: Network) => Promise<string>);
+        metadata?: Record<string, string> | undefined;
+    };
+}
+type CustomRailFactory = (address: string) => Method.AnyServer | readonly Method.AnyServer[];
+type ServerOf<N extends string, I extends string> = Omit<Method.AnyServer, 'name' | 'intent'> & {
+    name: N;
+    intent: I;
+};
+type TempoServer = ServerOf<'tempo', 'charge'>;
+type TempoSessionServer = ServerOf<'tempo', 'session'>;
+type SptServer = ServerOf<'stripe', 'charge'>;
+type EvmServer = ServerOf<'evm', 'charge'>;
+type BaseConfig = {
+    x402: NonNullable<Parameters<typeof evmCharge>[0]['x402']>;
+} & Partial<Omit<Parameters<typeof evmCharge>[0], 'currency' | 'recipient' | 'x402'>>;
+type CustomRailNetwork = Exclude<stripe.Network, 'tempo' | 'base'>;
+type AdditionalConfig = {
+    base?: BaseConfig;
+    tempo?: {
+        session: Omit<tempoSession.Parameters, 'currency' | 'recipient'>;
+    };
+} & {
+    [K in CustomRailNetwork]?: CustomRailFactory;
+};
+type DefaultMethods = readonly [TempoServer, SptServer];
+type DefaultMethodsWithAdditional<C extends AdditionalConfig> = readonly [
+    TempoServer,
+    SptServer,
+    ...(C extends {
+        base: object;
+    } ? [EvmServer] : []),
+    ...(C extends {
+        tempo: {
+            session: any;
+        };
+    } ? [TempoSessionServer] : [])
+];
+type DefaultMethodName = 'tempo' | 'spt';
+type DefaultMethodsConfig = {
+    exclude?: DefaultMethodName[];
+};
+type SyncMethodsResult = DefaultMethods & {
+    additional<C extends AdditionalConfig>(config: C): DefaultMethodsWithAdditional<C>;
+};
+interface StripeMachinePayments<P extends stripe.Parameters = stripe.Parameters> {
+    spt: {
+        charge: (params?: {
+            paymentMethodTypes?: string[];
+        }) => SptServer;
+    };
+    tempo: {
+        charge: (params: {
+            recipient: stripe.DepositAddress<'tempo'>;
+            metadata?: Record<string, string>;
+        } & Partial<Omit<Parameters<typeof tempoCharge>[0], 'currency' | 'recipient'>>) => TempoServer;
+        session: (params: {
+            recipient: stripe.DepositAddress<'tempo'>;
+        } & Omit<tempoSession.Parameters, 'currency' | 'recipient'>) => TempoSessionServer;
+    };
+    base: {
+        charge: (params: {
+            recipient: stripe.DepositAddress<'base'>;
+            metadata?: Record<string, string>;
+        } & BaseConfig) => EvmServer;
+    };
+    findOrCreateDepositAddress: <N extends stripe.Network>(network: N) => Promise<stripe.DepositAddress<N>>;
+    defaultMethods: (config?: DefaultMethodsConfig) => P['depositAddresses'] extends (network: stripe.Network) => Promise<string> ? DefaultMethodsBuilder : SyncMethodsResult;
+}
+declare class DefaultMethodsBuilder implements PromiseLike<DefaultMethods> {
+    #private;
+    constructor(resolve: (additional?: AdditionalConfig) => Promise<any>);
+    additional<C extends AdditionalConfig>(config: C): PromiseLike<DefaultMethodsWithAdditional<C>>;
+    then<T = DefaultMethods, U = never>(onfulfilled?: ((value: DefaultMethods) => T | PromiseLike<T>) | null, onrejected?: ((reason: unknown) => U | PromiseLike<U>) | null): Promise<T | U>;
+}
 /**
- * Creates a Stripe `charge` method for usage on the server.
+ * Creates a configured Stripe machine payments instance.
  *
  * @example
  * ```ts
  * import { Mppx, stripe } from 'mppx/server'
  *
+ * const machinePayments = stripe.create({
+ *   client: stripeClient,
+ *   networkId: process.env.STRIPE_PROFILE_ID!,
+ *   livemode: !process.env.STRIPE_SECRET_KEY!.includes('_test_'),
+ * })
+ *
+ * // Async: deposit addresses resolved from Stripe API
  * const mppx = Mppx.create({
- *   methods: [stripe({ secretKey: 'sk_...' })],
+ *   methods: await machinePayments.defaultMethods(),
+ *   secretKey: mppSecretKey,
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Sync: deposit addresses provided statically
+ * const machinePayments = stripe.create({
+ *   client: stripeClient,
+ *   networkId: process.env.STRIPE_PROFILE_ID!,
+ *   livemode: !process.env.STRIPE_SECRET_KEY!.includes('_test_'),
+ *   depositAddresses: { tempo: process.env.TEMPO_DEPOSIT_ADDRESS! },
+ * })
+ *
+ * const mppx = Mppx.create({
+ *   methods: machinePayments.defaultMethods(),
+ *   secretKey: mppSecretKey,
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With additional custom rails
+ * const mppx = Mppx.create({
+ *   methods: await machinePayments.defaultMethods().additional({
+ *     base: { x402: { facilitator } },
+ *     solana: (address) => solana.charge({ recipient: address, currency: USDC, decimals: 6 }),
+ *   }),
+ *   secretKey: mppSecretKey,
  * })
  * ```
  */
-export declare function stripe<const parameters extends stripe.Parameters>(parameters: parameters): readonly [import("../../Method.js").Server<{
-    readonly name: "stripe";
-    readonly intent: "charge";
-    readonly schema: {
-        readonly credential: {
-            readonly payload: import("zod/mini").ZodMiniObject<{
-                externalId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
-                spt: import("zod/mini").ZodMiniString<string>;
-            }, import("zod/v4/core").$strip>;
-        };
-        readonly request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
-            amount: import("zod/mini").ZodMiniString<string>;
-            currency: import("zod/mini").ZodMiniString<string>;
-            decimals: import("zod/mini").ZodMiniNumber<number>;
-            description: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
-            externalId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
-            metadata: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniRecord<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniString<string>>>;
-            networkId: import("zod/mini").ZodMiniString<string>;
-            paymentMethodTypes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>;
-            recipient: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
-        }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
-            amount: string;
-            methodDetails: {
-                metadata?: Record<string, string> | undefined;
-                networkId: string;
-                paymentMethodTypes: string[];
-            };
-            currency: string;
-            description?: string | undefined;
-            externalId?: string | undefined;
-            recipient?: string | undefined;
-        }, {
-            amount: string;
-            currency: string;
-            decimals: number;
-            networkId: string;
-            paymentMethodTypes: string[];
-            description?: string | undefined;
-            externalId?: string | undefined;
-            metadata?: Record<string, string> | undefined;
-            recipient?: string | undefined;
-        }>>;
-    };
-}, charge_.DeriveDefaults<parameters>, undefined, {}, undefined>];
+export declare function stripe<const P extends stripe.Parameters>(parameters: P): StripeMachinePayments<P>;
 export declare namespace stripe {
-    type Parameters = charge_.Parameters;
-    /** Creates a Stripe `charge` method for SPT-based payments. */
+    const spt: typeof charge_;
+    /** @deprecated Use `stripe.create({ ... }).spt.charge()` or `stripe.spt()` instead. */
     const charge: typeof charge_;
+    const create: typeof stripe;
+    const findOrCreateDepositAddress: typeof _findOrCreateDepositAddress;
 }
+export {};
 //# sourceMappingURL=Methods.d.ts.map

package/dist/stripe/server/Methods.js

@@ -1,21 +1,282 @@
+import * as EvmAssets from '../../evm/Assets.js';
+import { charge as evmCharge } from '../../evm/server/Charge.js';
+import * as tempoDefaults from '../../tempo/internal/defaults.js';
+import { charge as tempoCharge } from '../../tempo/server/Charge.js';
+import { session as tempoSession } from '../../tempo/session/server/Session.js';
 import { charge as charge_ } from './Charge.js';
+import { findOrCreateDepositAddress as _findOrCreateDepositAddress } from './internal/deposit-address.js';
+import { recordCryptoPayment } from './internal/record-payment.js';
+const defaultMethodNames = ['tempo', 'spt'];
+const additionalBuiltinKeys = ['base', 'tempo'];
+class DefaultMethodsBuilder {
+    #resolve;
+    #additional;
+    constructor(resolve) {
+        this.#resolve = resolve;
+    }
+    additional(config) {
+        this.#additional = config;
+        return this;
+    }
+    then(onfulfilled, onrejected) {
+        return this.#resolve(this.#additional).then(onfulfilled, onrejected);
+    }
+}
 /**
- * Creates a Stripe `charge` method for usage on the server.
+ * Creates a configured Stripe machine payments instance.
  *
  * @example
  * ```ts
  * import { Mppx, stripe } from 'mppx/server'
  *
+ * const machinePayments = stripe.create({
+ *   client: stripeClient,
+ *   networkId: process.env.STRIPE_PROFILE_ID!,
+ *   livemode: !process.env.STRIPE_SECRET_KEY!.includes('_test_'),
+ * })
+ *
+ * // Async: deposit addresses resolved from Stripe API
+ * const mppx = Mppx.create({
+ *   methods: await machinePayments.defaultMethods(),
+ *   secretKey: mppSecretKey,
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Sync: deposit addresses provided statically
+ * const machinePayments = stripe.create({
+ *   client: stripeClient,
+ *   networkId: process.env.STRIPE_PROFILE_ID!,
+ *   livemode: !process.env.STRIPE_SECRET_KEY!.includes('_test_'),
+ *   depositAddresses: { tempo: process.env.TEMPO_DEPOSIT_ADDRESS! },
+ * })
+ *
  * const mppx = Mppx.create({
- *   methods: [stripe({ secretKey: 'sk_...' })],
+ *   methods: machinePayments.defaultMethods(),
+ *   secretKey: mppSecretKey,
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With additional custom rails
+ * const mppx = Mppx.create({
+ *   methods: await machinePayments.defaultMethods().additional({
+ *     base: { x402: { facilitator } },
+ *     solana: (address) => solana.charge({ recipient: address, currency: USDC, decimals: 6 }),
+ *   }),
+ *   secretKey: mppSecretKey,
  * })
  * ```
  */
 export function stripe(parameters) {
-    return [stripe.charge(parameters)];
+    const { client, networkId, livemode, connect, depositAddresses, metadata } = parameters;
+    if (!client.rawRequest)
+        throw new Error('stripe.create() requires a Stripe SDK client with rawRequest() (v15+)');
+    const tempoCurrency = (livemode ? tempoDefaults.tokens.usdc : tempoDefaults.tokens.pathUsd);
+    const tempoPaymentHandler = createPaymentSuccessHandler(client, 'tempo', connect, metadata);
+    const basePaymentHandler = createPaymentSuccessHandler(client, 'base', connect, metadata);
+    // All stripe-managed crypto rails use 6-decimal stablecoins. Reject amounts
+    // below 1 cent since Stripe cannot record them.
+    const cryptoCanOffer = ({ request }) => Number(request.amount) >= 10_000;
+    function makeSptCharge(params) {
+        return charge_({
+            client,
+            networkId,
+            currency: 'usd',
+            decimals: 2,
+            paymentMethodTypes: params?.paymentMethodTypes ?? ['card', 'link'],
+            ...(connect && { connect }),
+            ...(metadata && { metadata }),
+        });
+    }
+    function makeTempoCharge(params) {
+        const { recipient, metadata: callMetadata, ...rest } = params;
+        const handler = callMetadata
+            ? createPaymentSuccessHandler(client, 'tempo', connect, { ...metadata, ...callMetadata })
+            : tempoPaymentHandler;
+        return tempoCharge({
+            currency: tempoCurrency,
+            recipient,
+            ...(!livemode && { testnet: true }),
+            canOffer: cryptoCanOffer,
+            onPaymentSuccess: handler,
+            ...rest,
+        });
+    }
+    function makeTempoSession(params) {
+        const { recipient, ...rest } = params;
+        return tempoSession({
+            currency: tempoCurrency,
+            recipient,
+            ...(!livemode && { testnet: true }),
+            ...rest,
+        });
+    }
+    function makeBaseCharge(params) {
+        const { recipient, x402, metadata: callMetadata, ...rest } = params;
+        const handler = callMetadata
+            ? createPaymentSuccessHandler(client, 'base', connect, { ...metadata, ...callMetadata })
+            : basePaymentHandler;
+        return evmCharge({
+            currency: livemode ? EvmAssets.base.USDC : EvmAssets.baseSepolia.USDC,
+            recipient,
+            x402,
+            canOffer: cryptoCanOffer,
+            onPaymentSuccess: handler,
+            ...rest,
+        });
+    }
+    const defaultMethodBuilders = {
+        tempo: (addresses) => {
+            const address = addresses.get('tempo');
+            if (!address)
+                return null;
+            return makeTempoCharge({ recipient: address });
+        },
+        spt: () => makeSptCharge(),
+    };
+    const additionalBuilders = {
+        base: (addresses, config) => {
+            if (!config.base)
+                return null;
+            const address = addresses.get('base');
+            if (!address)
+                return null;
+            return makeBaseCharge({ recipient: address, ...config.base });
+        },
+        tempo: (addresses, config) => {
+            if (!config.tempo?.session)
+                return null;
+            const address = addresses.get('tempo');
+            if (!address)
+                return null;
+            return makeTempoSession({ recipient: address, ...config.tempo.session });
+        },
+    };
+    function createMethodsFromAddresses(addresses, excluded, additional) {
+        const result = [];
+        for (const name of defaultMethodNames) {
+            if (excluded.has(name))
+                continue;
+            const method = defaultMethodBuilders[name](addresses);
+            if (method)
+                result.push(method);
+        }
+        if (additional) {
+            for (const key of Object.keys(additionalBuilders)) {
+                const method = additionalBuilders[key](addresses, additional);
+                if (method)
+                    result.push(method);
+            }
+            for (const [network, factory] of customRails(additional)) {
+                const address = requireAddress(addresses, network);
+                const recorder = createPaymentSuccessHandler(client, network, connect, metadata);
+                for (const m of toArray(factory(address))) {
+                    const onPaymentSuccess = m.onPaymentSuccess
+                        ? (params) => Promise.all([m.onPaymentSuccess(params), recorder(params)]).then(() => { })
+                        : recorder;
+                    const canOffer = m.canOffer
+                        ? (params) => cryptoCanOffer(params) && m.canOffer(params)
+                        : cryptoCanOffer;
+                    result.push({ ...m, canOffer, onPaymentSuccess });
+                }
+            }
+        }
+        return result;
+    }
+    function resolveAddress(network) {
+        if (typeof depositAddresses === 'function')
+            return depositAddresses(network);
+        return _findOrCreateDepositAddress(client, network, connect ? { connect } : undefined);
+    }
+    function defaultMethods(config) {
+        const excluded = new Set(config?.exclude);
+        if (typeof depositAddresses === 'function') {
+            // Async: resolve addresses dynamically
+            return new DefaultMethodsBuilder(async (additional) => {
+                const networks = neededNetworks(excluded, additional);
+                const results = await Promise.allSettled(networks.map(async (network) => ({
+                    network,
+                    address: await resolveAddress(network),
+                })));
+                const addresses = new Map();
+                for (const result of results) {
+                    if (result.status === 'fulfilled') {
+                        addresses.set(result.value.network, result.value.address);
+                    }
+                    else {
+                        const idx = results.indexOf(result);
+                        console.warn(`[stripe.create] ${networks[idx]} method excluded: ${result.reason?.message ?? result.reason}`);
+                    }
+                }
+                return createMethodsFromAddresses(addresses, excluded, additional);
+            });
+        }
+        const addresses = new Map(Object.entries(depositAddresses ?? {}));
+        return Object.assign(createMethodsFromAddresses(addresses, excluded), {
+            additional: (additional) => createMethodsFromAddresses(addresses, excluded, additional),
+        });
+    }
+    return {
+        spt: { charge: makeSptCharge },
+        tempo: { charge: makeTempoCharge, session: makeTempoSession },
+        base: { charge: makeBaseCharge },
+        findOrCreateDepositAddress: async (network) => {
+            const address = await resolveAddress(network);
+            return address;
+        },
+        defaultMethods,
+    };
 }
 (function (stripe) {
-    /** Creates a Stripe `charge` method for SPT-based payments. */
+    stripe.spt = charge_;
+    /** @deprecated Use `stripe.create({ ... }).spt.charge()` or `stripe.spt()` instead. */
     stripe.charge = charge_;
+    stripe.create = stripe;
+    stripe.findOrCreateDepositAddress = _findOrCreateDepositAddress;
 })(stripe || (stripe = {}));
+function neededNetworks(excluded, additional) {
+    const networks = [];
+    if (!excluded.has('tempo') || additional?.tempo?.session)
+        networks.push('tempo');
+    if (additional?.base)
+        networks.push('base');
+    for (const [network] of customRails(additional)) {
+        networks.push(network);
+    }
+    return networks;
+}
+function requireAddress(addresses, network) {
+    const address = addresses.get(network);
+    if (!address)
+        throw new Error(`stripe: missing deposit address for ${network}`);
+    return address;
+}
+function toArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function customRails(additional) {
+    if (!additional)
+        return [];
+    return Object.entries(additional).filter((entry) => {
+        const [k, v] = entry;
+        return !additionalBuiltinKeys.includes(k) && typeof v === 'function';
+    });
+}
+function createPaymentSuccessHandler(client, network, connect, metadata) {
+    return (params) => {
+        const { receipt, request } = params;
+        if (receipt?.reference && request?.amount) {
+            return recordCryptoPayment(client, {
+                network,
+                reference: receipt.reference,
+                amount: String(request.amount),
+                ...(connect && { connect }),
+                ...(metadata && { metadata }),
+            });
+        }
+    };
+}
 //# sourceMappingURL=Methods.js.map

package/dist/stripe/server/internal/deposit-address.d.ts

@@ -0,0 +1,13 @@
+import type { StripeClient } from '../../internal/types.js';
+import { type ConnectConfig } from './request.js';
+export type DepositAddressResolver = (client: StripeClient, network: string, options?: {
+    connect?: ConnectConfig;
+}) => Promise<string>;
+/**
+ * Finds an existing deposit address or creates a new one for the given network.
+ * Cached per client+network+stripeAccount for the process lifetime.
+ */
+export declare function findOrCreateDepositAddress(client: StripeClient, network: string, options?: {
+    connect?: ConnectConfig;
+}): Promise<string>;
+//# sourceMappingURL=deposit-address.d.ts.map

package/dist/stripe/server/internal/deposit-address.js

@@ -0,0 +1,28 @@
+import { stripeRequest } from './request.js';
+const cache = new WeakMap();
+/**
+ * Finds an existing deposit address or creates a new one for the given network.
+ * Cached per client+network+stripeAccount for the process lifetime.
+ */
+export async function findOrCreateDepositAddress(client, network, options) {
+    let clientCache = cache.get(client);
+    if (!clientCache) {
+        clientCache = new Map();
+        cache.set(client, clientCache);
+    }
+    const key = options?.connect?.stripeAccount
+        ? `${options.connect.stripeAccount}:${network}`
+        : network;
+    const cached = clientCache.get(key);
+    if (cached)
+        return cached;
+    const list = (await stripeRequest(client, 'GET', `/v1/crypto/deposit_addresses?network=${network}&limit=1`, undefined, options));
+    if (list.data && list.data.length > 0) {
+        clientCache.set(key, list.data[0].address);
+        return list.data[0].address;
+    }
+    const created = (await stripeRequest(client, 'POST', '/v1/crypto/deposit_addresses', { network }, options));
+    clientCache.set(key, created.address);
+    return created.address;
+}
+//# sourceMappingURL=deposit-address.js.map