@wopr-network/platform-core 1.47.0 → 1.48.0

package/dist/billing/payment-processor.d.ts

@@ -105,6 +105,8 @@ export interface IPaymentProcessor {
     charge(opts: ChargeOpts): Promise<ChargeResult>;
     /** Detach a payment method from the tenant's account. */
     detachPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
+    /** Set a payment method as the tenant's default for future invoices. */
+    setDefaultPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
     /** Get the billing email for a tenant's customer account. Returns "" if no customer exists. */
     getCustomerEmail(tenantId: string): Promise<string>;
     /** Update the billing email for a tenant's customer account. */

package/dist/billing/payment-processor.test.js

@@ -45,6 +45,7 @@ describe("IPaymentProcessor types", () => {
             setupPaymentMethod: async () => ({ clientSecret: "cs" }),
             listPaymentMethods: async () => [],
             detachPaymentMethod: async () => undefined,
+            setDefaultPaymentMethod: async () => undefined,
             charge: async () => ({ success: true }),
             getCustomerEmail: async () => "",
             updateCustomerEmail: async () => undefined,

package/dist/billing/stripe/stripe-payment-processor.d.ts

@@ -41,6 +41,7 @@ export declare class StripePaymentProcessor implements IPaymentProcessor {
     }>;
     setupPaymentMethod(tenant: string): Promise<SetupResult>;
     listPaymentMethods(tenant: string): Promise<SavedPaymentMethod[]>;
+    setDefaultPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
     detachPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
     getCustomerEmail(tenantId: string): Promise<string>;
     updateCustomerEmail(tenantId: string, email: string): Promise<void>;

package/dist/billing/stripe/stripe-payment-processor.js

@@ -86,20 +86,43 @@ export class StripePaymentProcessor {
         if (!mapping) {
             return [];
         }
-        const methods = await this.stripe.customers.listPaymentMethods(mapping.processor_customer_id);
-        return methods.data.map((pm, index) => ({
+        const [methods, customer] = await Promise.all([
+            this.stripe.customers.listPaymentMethods(mapping.processor_customer_id),
+            this.stripe.customers.retrieve(mapping.processor_customer_id),
+        ]);
+        const defaultPmId = !customer.deleted && customer.invoice_settings?.default_payment_method
+            ? typeof customer.invoice_settings.default_payment_method === "string"
+                ? customer.invoice_settings.default_payment_method
+                : customer.invoice_settings.default_payment_method.id
+            : null;
+        return methods.data.map((pm) => ({
             id: pm.id,
             label: formatPaymentMethodLabel(pm),
-            isDefault: index === 0,
+            isDefault: defaultPmId ? pm.id === defaultPmId : false,
         }));
     }
+    async setDefaultPaymentMethod(tenant, paymentMethodId) {
+        const mapping = await this.tenantRepo.getByTenant(tenant);
+        if (!mapping) {
+            throw new Error(`No Stripe customer found for tenant: ${tenant}`);
+        }
+        const pm = await this.stripe.paymentMethods.retrieve(paymentMethodId);
+        const pmCustomerId = typeof pm.customer === "string" ? pm.customer : (pm.customer?.id ?? null);
+        if (!pmCustomerId || pmCustomerId !== mapping.processor_customer_id) {
+            throw new PaymentMethodOwnershipError();
+        }
+        await this.stripe.customers.update(mapping.processor_customer_id, {
+            invoice_settings: { default_payment_method: paymentMethodId },
+        });
+    }
     async detachPaymentMethod(tenant, paymentMethodId) {
         const mapping = await this.tenantRepo.getByTenant(tenant);
         if (!mapping) {
             throw new Error(`No Stripe customer found for tenant: ${tenant}`);
         }
         const pm = await this.stripe.paymentMethods.retrieve(paymentMethodId);
-        if (!pm.customer || pm.customer !== mapping.processor_customer_id) {
+        const pmCustomerId = typeof pm.customer === "string" ? pm.customer : (pm.customer?.id ?? null);
+        if (!pmCustomerId || pmCustomerId !== mapping.processor_customer_id) {
             throw new PaymentMethodOwnershipError();
         }
         await this.stripe.paymentMethods.detach(paymentMethodId);

package/dist/billing/stripe/stripe-payment-processor.test.js

@@ -96,7 +96,7 @@ describe("StripePaymentProcessor", () => {
             const result = await processor.listPaymentMethods("tenant-1");
             expect(result).toEqual([]);
         });
-        it("returns formatted payment methods with card label", async () => {
+        it("returns formatted payment methods with card label and reads actual Stripe default", async () => {
             vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
             vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
                 data: [
@@ -104,17 +104,55 @@ describe("StripePaymentProcessor", () => {
                     { id: "pm_2", card: { brand: "mastercard", last4: "5555" } },
                 ],
             });
+            vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+                deleted: false,
+                invoice_settings: { default_payment_method: "pm_1" },
+            });
             const result = await processor.listPaymentMethods("tenant-1");
             expect(result).toEqual([
                 { id: "pm_1", label: "Visa ending 4242", isDefault: true },
                 { id: "pm_2", label: "Mastercard ending 5555", isDefault: false },
             ]);
         });
+        it("marks second PM as default when Stripe says so", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
+                data: [
+                    { id: "pm_1", card: { brand: "visa", last4: "4242" } },
+                    { id: "pm_2", card: { brand: "mastercard", last4: "5555" } },
+                ],
+            });
+            vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+                deleted: false,
+                invoice_settings: { default_payment_method: "pm_2" },
+            });
+            const result = await processor.listPaymentMethods("tenant-1");
+            expect(result).toEqual([
+                { id: "pm_1", label: "Visa ending 4242", isDefault: false },
+                { id: "pm_2", label: "Mastercard ending 5555", isDefault: true },
+            ]);
+        });
+        it("marks no PM as default when customer has no default set", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
+                data: [{ id: "pm_1", card: { brand: "visa", last4: "4242" } }],
+            });
+            vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+                deleted: false,
+                invoice_settings: { default_payment_method: null },
+            });
+            const result = await processor.listPaymentMethods("tenant-1");
+            expect(result).toEqual([{ id: "pm_1", label: "Visa ending 4242", isDefault: false }]);
+        });
         it("uses generic label for non-card payment methods", async () => {
             vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
             vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
                 data: [{ id: "pm_bank", card: undefined }],
             });
+            vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+                deleted: false,
+                invoice_settings: { default_payment_method: "pm_bank" },
+            });
             const result = await processor.listPaymentMethods("tenant-1");
             expect(result).toEqual([{ id: "pm_bank", label: "Payment method pm_bank", isDefault: true }]);
         });
@@ -152,6 +190,62 @@ describe("StripePaymentProcessor", () => {
             expect(mocks.stripe.paymentMethods.detach).toHaveBeenCalledWith("pm_1");
         });
     });
+    // --- setDefaultPaymentMethod ---
+    describe("setDefaultPaymentMethod", () => {
+        it("throws when tenant has no Stripe customer", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(null);
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow("No Stripe customer found for tenant: tenant-1");
+        });
+        it("throws PaymentMethodOwnershipError when PM belongs to different customer", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: "cus_OTHER",
+            });
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+        });
+        it("throws PaymentMethodOwnershipError when PM has no customer", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: null,
+            });
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+        });
+        it("calls stripe.customers.update with invoice_settings when ownership matches", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: "cus_123",
+            });
+            vi.mocked(mocks.stripe.customers.update).mockResolvedValue({});
+            await processor.setDefaultPaymentMethod("tenant-1", "pm_1");
+            expect(mocks.stripe.customers.update).toHaveBeenCalledWith("cus_123", {
+                invoice_settings: { default_payment_method: "pm_1" },
+            });
+        });
+        it("succeeds when PM customer is an expanded Customer object", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: { id: "cus_123", object: "customer" },
+            });
+            vi.mocked(mocks.stripe.customers.update).mockResolvedValue({});
+            await processor.setDefaultPaymentMethod("tenant-1", "pm_1");
+            expect(mocks.stripe.customers.update).toHaveBeenCalledWith("cus_123", {
+                invoice_settings: { default_payment_method: "pm_1" },
+            });
+        });
+        it("propagates Stripe API errors", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: "cus_123",
+            });
+            vi.mocked(mocks.stripe.customers.update).mockRejectedValue(new Error("Stripe API error"));
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow("Stripe API error");
+        });
+    });
     // --- getCustomerEmail ---
     describe("getCustomerEmail", () => {
         it("returns empty string when tenant has no Stripe customer", async () => {

package/dist/monetization/stripe/stripe-payment-processor.d.ts

@@ -33,6 +33,7 @@ export declare class StripePaymentProcessor implements IPaymentProcessor {
     }>;
     setupPaymentMethod(tenant: string): Promise<SetupResult>;
     listPaymentMethods(tenant: string): Promise<SavedPaymentMethod[]>;
+    setDefaultPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
     detachPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
     getCustomerEmail(tenantId: string): Promise<string>;
     updateCustomerEmail(tenantId: string, email: string): Promise<void>;

package/dist/monetization/stripe/stripe-payment-processor.js

@@ -89,13 +89,35 @@ export class StripePaymentProcessor {
         if (!mapping) {
             return [];
         }
-        const methods = await this.stripe.customers.listPaymentMethods(mapping.processor_customer_id);
-        return methods.data.map((pm, index) => ({
+        const [methods, customer] = await Promise.all([
+            this.stripe.customers.listPaymentMethods(mapping.processor_customer_id),
+            this.stripe.customers.retrieve(mapping.processor_customer_id),
+        ]);
+        const defaultPmId = !customer.deleted && customer.invoice_settings?.default_payment_method
+            ? typeof customer.invoice_settings.default_payment_method === "string"
+                ? customer.invoice_settings.default_payment_method
+                : customer.invoice_settings.default_payment_method.id
+            : null;
+        return methods.data.map((pm) => ({
             id: pm.id,
             label: formatPaymentMethodLabel(pm),
-            isDefault: index === 0,
+            isDefault: defaultPmId ? pm.id === defaultPmId : false,
         }));
     }
+    async setDefaultPaymentMethod(tenant, paymentMethodId) {
+        const mapping = await this.tenantRepo.getByTenant(tenant);
+        if (!mapping) {
+            throw new Error(`No Stripe customer found for tenant: ${tenant}`);
+        }
+        const pm = await this.stripe.paymentMethods.retrieve(paymentMethodId);
+        const pmCustomerId = typeof pm.customer === "string" ? pm.customer : (pm.customer?.id ?? null);
+        if (!pmCustomerId || pmCustomerId !== mapping.processor_customer_id) {
+            throw new PaymentMethodOwnershipError();
+        }
+        await this.stripe.customers.update(mapping.processor_customer_id, {
+            invoice_settings: { default_payment_method: paymentMethodId },
+        });
+    }
     async detachPaymentMethod(tenant, paymentMethodId) {
         const mapping = await this.tenantRepo.getByTenant(tenant);
         if (!mapping) {

package/dist/monetization/stripe/stripe-payment-processor.test.js

@@ -102,7 +102,7 @@ describe("StripePaymentProcessor", () => {
             const result = await processor.listPaymentMethods("tenant-1");
             expect(result).toEqual([]);
         });
-        it("returns formatted payment methods with card label", async () => {
+        it("returns formatted payment methods with card label and reads actual Stripe default", async () => {
             vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
             vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
                 data: [
@@ -110,6 +110,10 @@ describe("StripePaymentProcessor", () => {
                     { id: "pm_2", card: { brand: "mastercard", last4: "5555" } },
                 ],
             });
+            vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+                deleted: false,
+                invoice_settings: { default_payment_method: "pm_1" },
+            });
             const result = await processor.listPaymentMethods("tenant-1");
             expect(result).toEqual([
                 { id: "pm_1", label: "Visa ending 4242", isDefault: true },
@@ -121,6 +125,10 @@ describe("StripePaymentProcessor", () => {
             vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
                 data: [{ id: "pm_bank", card: undefined }],
             });
+            vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+                deleted: false,
+                invoice_settings: { default_payment_method: "pm_bank" },
+            });
             const result = await processor.listPaymentMethods("tenant-1");
             expect(result).toEqual([{ id: "pm_bank", label: "Payment method pm_bank", isDefault: true }]);
         });
@@ -158,6 +166,70 @@ describe("StripePaymentProcessor", () => {
             expect(mocks.stripe.paymentMethods.detach).toHaveBeenCalledWith("pm_1");
         });
     });
+    // --- setDefaultPaymentMethod ---
+    describe("setDefaultPaymentMethod", () => {
+        it("throws when tenant has no Stripe customer", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(null);
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow("No Stripe customer found for tenant: tenant-1");
+        });
+        it("throws PaymentMethodOwnershipError when PM has no customer", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: null,
+            });
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+        });
+        it("throws PaymentMethodOwnershipError when PM belongs to different customer", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: "cus_OTHER",
+            });
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+        });
+        it("throws PaymentMethodOwnershipError when PM customer is an expanded object with different id", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: { id: "cus_OTHER", object: "customer" },
+            });
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+        });
+        it("sets default when ownership matches (string customer)", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: "cus_123",
+            });
+            vi.mocked(mocks.stripe.customers.update).mockResolvedValue({});
+            await processor.setDefaultPaymentMethod("tenant-1", "pm_1");
+            expect(mocks.stripe.customers.update).toHaveBeenCalledWith("cus_123", {
+                invoice_settings: { default_payment_method: "pm_1" },
+            });
+        });
+        it("sets default when ownership matches (expanded Customer object)", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: { id: "cus_123", object: "customer" },
+            });
+            vi.mocked(mocks.stripe.customers.update).mockResolvedValue({});
+            await processor.setDefaultPaymentMethod("tenant-1", "pm_1");
+            expect(mocks.stripe.customers.update).toHaveBeenCalledWith("cus_123", {
+                invoice_settings: { default_payment_method: "pm_1" },
+            });
+        });
+        it("propagates Stripe errors", async () => {
+            vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+            vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+                id: "pm_1",
+                customer: "cus_123",
+            });
+            vi.mocked(mocks.stripe.customers.update).mockRejectedValue(new Error("Stripe network error"));
+            await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow("Stripe network error");
+        });
+    });
     // --- getCustomerEmail ---
     describe("getCustomerEmail", () => {
         it("returns empty string when tenant has no Stripe customer", async () => {

package/dist/trpc/org-remove-payment-method-router.test.js

@@ -38,6 +38,7 @@ function makeMockProcessor(methods) {
         getCustomerEmail: vi.fn().mockResolvedValue(""),
         updateCustomerEmail: vi.fn(),
         listInvoices: vi.fn().mockResolvedValue([]),
+        setDefaultPaymentMethod: vi.fn().mockResolvedValue(undefined),
     };
 }
 function makeMockAutoTopupSettings(overrides) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.47.0",
+  "version": "1.48.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/billing/payment-processor.test.ts

@@ -63,6 +63,7 @@ describe("IPaymentProcessor types", () => {
       setupPaymentMethod: async () => ({ clientSecret: "cs" }),
       listPaymentMethods: async () => [],
       detachPaymentMethod: async () => undefined,
+      setDefaultPaymentMethod: async () => undefined,
       charge: async () => ({ success: true }),
       getCustomerEmail: async () => "",
       updateCustomerEmail: async () => undefined,

package/src/billing/payment-processor.ts

@@ -125,6 +125,9 @@ export interface IPaymentProcessor {
   /** Detach a payment method from the tenant's account. */
   detachPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
 
+  /** Set a payment method as the tenant's default for future invoices. */
+  setDefaultPaymentMethod(tenant: string, paymentMethodId: string): Promise<void>;
+
   /** Get the billing email for a tenant's customer account. Returns "" if no customer exists. */
   getCustomerEmail(tenantId: string): Promise<string>;
 

package/src/billing/stripe/stripe-payment-processor.test.ts

@@ -120,7 +120,7 @@ describe("StripePaymentProcessor", () => {
       expect(result).toEqual([]);
     });
 
-    it("returns formatted payment methods with card label", async () => {
+    it("returns formatted payment methods with card label and reads actual Stripe default", async () => {
       vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
       vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
         data: [
@@ -128,6 +128,10 @@ describe("StripePaymentProcessor", () => {
           { id: "pm_2", card: { brand: "mastercard", last4: "5555" } },
         ],
       } as unknown as Stripe.Response<Stripe.ApiList<Stripe.PaymentMethod>>);
+      vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+        deleted: false,
+        invoice_settings: { default_payment_method: "pm_1" },
+      } as unknown as Stripe.Response<Stripe.Customer>);
 
       const result = await processor.listPaymentMethods("tenant-1");
       expect(result).toEqual([
@@ -136,11 +140,49 @@ describe("StripePaymentProcessor", () => {
       ]);
     });
 
+    it("marks second PM as default when Stripe says so", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
+        data: [
+          { id: "pm_1", card: { brand: "visa", last4: "4242" } },
+          { id: "pm_2", card: { brand: "mastercard", last4: "5555" } },
+        ],
+      } as unknown as Stripe.Response<Stripe.ApiList<Stripe.PaymentMethod>>);
+      vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+        deleted: false,
+        invoice_settings: { default_payment_method: "pm_2" },
+      } as unknown as Stripe.Response<Stripe.Customer>);
+
+      const result = await processor.listPaymentMethods("tenant-1");
+      expect(result).toEqual([
+        { id: "pm_1", label: "Visa ending 4242", isDefault: false },
+        { id: "pm_2", label: "Mastercard ending 5555", isDefault: true },
+      ]);
+    });
+
+    it("marks no PM as default when customer has no default set", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
+        data: [{ id: "pm_1", card: { brand: "visa", last4: "4242" } }],
+      } as unknown as Stripe.Response<Stripe.ApiList<Stripe.PaymentMethod>>);
+      vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+        deleted: false,
+        invoice_settings: { default_payment_method: null },
+      } as unknown as Stripe.Response<Stripe.Customer>);
+
+      const result = await processor.listPaymentMethods("tenant-1");
+      expect(result).toEqual([{ id: "pm_1", label: "Visa ending 4242", isDefault: false }]);
+    });
+
     it("uses generic label for non-card payment methods", async () => {
       vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
       vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
         data: [{ id: "pm_bank", card: undefined }],
       } as unknown as Stripe.Response<Stripe.ApiList<Stripe.PaymentMethod>>);
+      vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+        deleted: false,
+        invoice_settings: { default_payment_method: "pm_bank" },
+      } as unknown as Stripe.Response<Stripe.Customer>);
 
       const result = await processor.listPaymentMethods("tenant-1");
       expect(result).toEqual([{ id: "pm_bank", label: "Payment method pm_bank", isDefault: true }]);
@@ -192,6 +234,76 @@ describe("StripePaymentProcessor", () => {
     });
   });
 
+  // --- setDefaultPaymentMethod ---
+
+  describe("setDefaultPaymentMethod", () => {
+    it("throws when tenant has no Stripe customer", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(null);
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(
+        "No Stripe customer found for tenant: tenant-1",
+      );
+    });
+
+    it("throws PaymentMethodOwnershipError when PM belongs to different customer", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: "cus_OTHER",
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+    });
+
+    it("throws PaymentMethodOwnershipError when PM has no customer", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: null,
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+    });
+
+    it("calls stripe.customers.update with invoice_settings when ownership matches", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: "cus_123",
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+      vi.mocked(mocks.stripe.customers.update).mockResolvedValue({} as unknown as Stripe.Response<Stripe.Customer>);
+
+      await processor.setDefaultPaymentMethod("tenant-1", "pm_1");
+      expect(mocks.stripe.customers.update).toHaveBeenCalledWith("cus_123", {
+        invoice_settings: { default_payment_method: "pm_1" },
+      });
+    });
+
+    it("succeeds when PM customer is an expanded Customer object", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: { id: "cus_123", object: "customer" },
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+      vi.mocked(mocks.stripe.customers.update).mockResolvedValue({} as unknown as Stripe.Response<Stripe.Customer>);
+
+      await processor.setDefaultPaymentMethod("tenant-1", "pm_1");
+      expect(mocks.stripe.customers.update).toHaveBeenCalledWith("cus_123", {
+        invoice_settings: { default_payment_method: "pm_1" },
+      });
+    });
+
+    it("propagates Stripe API errors", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: "cus_123",
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+      vi.mocked(mocks.stripe.customers.update).mockRejectedValue(new Error("Stripe API error"));
+
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow("Stripe API error");
+    });
+  });
+
   // --- getCustomerEmail ---
 
   describe("getCustomerEmail", () => {

package/src/billing/stripe/stripe-payment-processor.ts

@@ -154,15 +154,42 @@ export class StripePaymentProcessor implements IPaymentProcessor {
       return [];
     }
 
-    const methods = await this.stripe.customers.listPaymentMethods(mapping.processor_customer_id);
-
-    return methods.data.map((pm, index) => ({
+    const [methods, customer] = await Promise.all([
+      this.stripe.customers.listPaymentMethods(mapping.processor_customer_id),
+      this.stripe.customers.retrieve(mapping.processor_customer_id),
+    ]);
+
+    const defaultPmId =
+      !customer.deleted && customer.invoice_settings?.default_payment_method
+        ? typeof customer.invoice_settings.default_payment_method === "string"
+          ? customer.invoice_settings.default_payment_method
+          : customer.invoice_settings.default_payment_method.id
+        : null;
+
+    return methods.data.map((pm) => ({
       id: pm.id,
       label: formatPaymentMethodLabel(pm),
-      isDefault: index === 0,
+      isDefault: defaultPmId ? pm.id === defaultPmId : false,
     }));
   }
 
+  async setDefaultPaymentMethod(tenant: string, paymentMethodId: string): Promise<void> {
+    const mapping = await this.tenantRepo.getByTenant(tenant);
+    if (!mapping) {
+      throw new Error(`No Stripe customer found for tenant: ${tenant}`);
+    }
+
+    const pm = await this.stripe.paymentMethods.retrieve(paymentMethodId);
+    const pmCustomerId = typeof pm.customer === "string" ? pm.customer : (pm.customer?.id ?? null);
+    if (!pmCustomerId || pmCustomerId !== mapping.processor_customer_id) {
+      throw new PaymentMethodOwnershipError();
+    }
+
+    await this.stripe.customers.update(mapping.processor_customer_id, {
+      invoice_settings: { default_payment_method: paymentMethodId },
+    });
+  }
+
   async detachPaymentMethod(tenant: string, paymentMethodId: string): Promise<void> {
     const mapping = await this.tenantRepo.getByTenant(tenant);
     if (!mapping) {
@@ -170,7 +197,8 @@ export class StripePaymentProcessor implements IPaymentProcessor {
     }
 
     const pm = await this.stripe.paymentMethods.retrieve(paymentMethodId);
-    if (!pm.customer || pm.customer !== mapping.processor_customer_id) {
+    const pmCustomerId = typeof pm.customer === "string" ? pm.customer : (pm.customer?.id ?? null);
+    if (!pmCustomerId || pmCustomerId !== mapping.processor_customer_id) {
       throw new PaymentMethodOwnershipError();
     }
 

package/src/monetization/stripe/stripe-payment-processor.test.ts

@@ -129,7 +129,7 @@ describe("StripePaymentProcessor", () => {
       expect(result).toEqual([]);
     });
 
-    it("returns formatted payment methods with card label", async () => {
+    it("returns formatted payment methods with card label and reads actual Stripe default", async () => {
       vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
       vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
         data: [
@@ -137,6 +137,10 @@ describe("StripePaymentProcessor", () => {
           { id: "pm_2", card: { brand: "mastercard", last4: "5555" } },
         ],
       } as unknown as Stripe.Response<Stripe.ApiList<Stripe.PaymentMethod>>);
+      vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+        deleted: false,
+        invoice_settings: { default_payment_method: "pm_1" },
+      } as unknown as Stripe.Response<Stripe.Customer>);
 
       const result = await processor.listPaymentMethods("tenant-1");
       expect(result).toEqual([
@@ -150,6 +154,10 @@ describe("StripePaymentProcessor", () => {
       vi.mocked(mocks.stripe.customers.listPaymentMethods).mockResolvedValue({
         data: [{ id: "pm_bank", card: undefined }],
       } as unknown as Stripe.Response<Stripe.ApiList<Stripe.PaymentMethod>>);
+      vi.mocked(mocks.stripe.customers.retrieve).mockResolvedValue({
+        deleted: false,
+        invoice_settings: { default_payment_method: "pm_bank" },
+      } as unknown as Stripe.Response<Stripe.Customer>);
 
       const result = await processor.listPaymentMethods("tenant-1");
       expect(result).toEqual([{ id: "pm_bank", label: "Payment method pm_bank", isDefault: true }]);
@@ -201,6 +209,86 @@ describe("StripePaymentProcessor", () => {
     });
   });
 
+  // --- setDefaultPaymentMethod ---
+
+  describe("setDefaultPaymentMethod", () => {
+    it("throws when tenant has no Stripe customer", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(null);
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(
+        "No Stripe customer found for tenant: tenant-1",
+      );
+    });
+
+    it("throws PaymentMethodOwnershipError when PM has no customer", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: null,
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+    });
+
+    it("throws PaymentMethodOwnershipError when PM belongs to different customer", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: "cus_OTHER",
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+    });
+
+    it("throws PaymentMethodOwnershipError when PM customer is an expanded object with different id", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: { id: "cus_OTHER", object: "customer" },
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow(PaymentMethodOwnershipError);
+    });
+
+    it("sets default when ownership matches (string customer)", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: "cus_123",
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+      vi.mocked(mocks.stripe.customers.update).mockResolvedValue({} as unknown as Stripe.Response<Stripe.Customer>);
+
+      await processor.setDefaultPaymentMethod("tenant-1", "pm_1");
+      expect(mocks.stripe.customers.update).toHaveBeenCalledWith("cus_123", {
+        invoice_settings: { default_payment_method: "pm_1" },
+      });
+    });
+
+    it("sets default when ownership matches (expanded Customer object)", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: { id: "cus_123", object: "customer" },
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+      vi.mocked(mocks.stripe.customers.update).mockResolvedValue({} as unknown as Stripe.Response<Stripe.Customer>);
+
+      await processor.setDefaultPaymentMethod("tenant-1", "pm_1");
+      expect(mocks.stripe.customers.update).toHaveBeenCalledWith("cus_123", {
+        invoice_settings: { default_payment_method: "pm_1" },
+      });
+    });
+
+    it("propagates Stripe errors", async () => {
+      vi.mocked(mocks.tenantRepo.getByTenant).mockResolvedValue(makeTenantRow());
+      vi.mocked(mocks.stripe.paymentMethods.retrieve).mockResolvedValue({
+        id: "pm_1",
+        customer: "cus_123",
+      } as unknown as Stripe.Response<Stripe.PaymentMethod>);
+      vi.mocked(mocks.stripe.customers.update).mockRejectedValue(new Error("Stripe network error"));
+
+      await expect(processor.setDefaultPaymentMethod("tenant-1", "pm_1")).rejects.toThrow("Stripe network error");
+    });
+  });
+
   // --- getCustomerEmail ---
 
   describe("getCustomerEmail", () => {

package/src/monetization/stripe/stripe-payment-processor.ts

@@ -154,15 +154,42 @@ export class StripePaymentProcessor implements IPaymentProcessor {
       return [];
     }
 
-    const methods = await this.stripe.customers.listPaymentMethods(mapping.processor_customer_id);
-
-    return methods.data.map((pm, index) => ({
+    const [methods, customer] = await Promise.all([
+      this.stripe.customers.listPaymentMethods(mapping.processor_customer_id),
+      this.stripe.customers.retrieve(mapping.processor_customer_id),
+    ]);
+
+    const defaultPmId =
+      !customer.deleted && customer.invoice_settings?.default_payment_method
+        ? typeof customer.invoice_settings.default_payment_method === "string"
+          ? customer.invoice_settings.default_payment_method
+          : customer.invoice_settings.default_payment_method.id
+        : null;
+
+    return methods.data.map((pm) => ({
       id: pm.id,
       label: formatPaymentMethodLabel(pm),
-      isDefault: index === 0,
+      isDefault: defaultPmId ? pm.id === defaultPmId : false,
     }));
   }
 
+  async setDefaultPaymentMethod(tenant: string, paymentMethodId: string): Promise<void> {
+    const mapping = await this.tenantRepo.getByTenant(tenant);
+    if (!mapping) {
+      throw new Error(`No Stripe customer found for tenant: ${tenant}`);
+    }
+
+    const pm = await this.stripe.paymentMethods.retrieve(paymentMethodId);
+    const pmCustomerId = typeof pm.customer === "string" ? pm.customer : (pm.customer?.id ?? null);
+    if (!pmCustomerId || pmCustomerId !== mapping.processor_customer_id) {
+      throw new PaymentMethodOwnershipError();
+    }
+
+    await this.stripe.customers.update(mapping.processor_customer_id, {
+      invoice_settings: { default_payment_method: paymentMethodId },
+    });
+  }
+
   async detachPaymentMethod(tenant: string, paymentMethodId: string): Promise<void> {
     const mapping = await this.tenantRepo.getByTenant(tenant);
     if (!mapping) {

package/src/trpc/org-remove-payment-method-router.test.ts

@@ -44,6 +44,7 @@ function makeMockProcessor(methods: SavedPaymentMethod[]): IPaymentProcessor {
     getCustomerEmail: vi.fn().mockResolvedValue(""),
     updateCustomerEmail: vi.fn(),
     listInvoices: vi.fn().mockResolvedValue([]),
+    setDefaultPaymentMethod: vi.fn().mockResolvedValue(undefined),
   };
 }