@wopr-network/platform-core 1.47.0 → 1.49.0

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/db/schema/crypto.d.ts

@@ -282,6 +282,74 @@ export declare const cryptoCharges: import("drizzle-orm/pg-core").PgTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        confirmations: import("drizzle-orm/pg-core").PgColumn<{
+            name: "confirmations";
+            tableName: "crypto_charges";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        confirmationsRequired: import("drizzle-orm/pg-core").PgColumn<{
+            name: "confirmations_required";
+            tableName: "crypto_charges";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        txHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tx_hash";
+            tableName: "crypto_charges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        amountReceivedCents: import("drizzle-orm/pg-core").PgColumn<{
+            name: "amount_received_cents";
+            tableName: "crypto_charges";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;

package/dist/db/schema/crypto.js

@@ -27,6 +27,14 @@ export const cryptoCharges = pgTable("crypto_charges", {
     expectedAmount: text("expected_amount"),
     /** Running total of received crypto in native units. Accumulates across partial payments. */
     receivedAmount: text("received_amount"),
+    /** Number of blockchain confirmations observed so far. */
+    confirmations: integer("confirmations").notNull().default(0),
+    /** Required confirmations for settlement (copied from payment method at creation). */
+    confirmationsRequired: integer("confirmations_required").notNull().default(1),
+    /** Blockchain transaction hash for the payment. */
+    txHash: text("tx_hash"),
+    /** Amount received so far in USD cents (integer). Converted from crypto at time of receipt. */
+    amountReceivedCents: integer("amount_received_cents").notNull().default(0),
 }, (table) => [
     index("idx_crypto_charges_tenant").on(table.tenantId),
     index("idx_crypto_charges_status").on(table.status),

package/dist/monetization/crypto/__tests__/webhook.test.js

@@ -120,7 +120,8 @@ describe("handleCryptoWebhook (monetization layer)", () => {
         it("updates charge status on every webhook call", async () => {
             await handleCryptoWebhook(deps, makePayload({ status: "partial" }));
             const charge = await chargeStore.getByReferenceId("chg-test-001");
-            expect(charge?.status).toBe("partial");
+            // DB stores legacy status values; "partial" maps to "Processing" internally
+            expect(charge?.status).toBe("Processing");
         });
         it("settles charge when status is confirmed", async () => {
             await handleCryptoWebhook(deps, makePayload({ status: "confirmed" }));

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/drizzle/migrations/0016_charge_progress_columns.sql

@@ -0,0 +1,4 @@
+ALTER TABLE "crypto_charges" ADD COLUMN "confirmations" integer DEFAULT 0 NOT NULL;--> statement-breakpoint
+ALTER TABLE "crypto_charges" ADD COLUMN "confirmations_required" integer DEFAULT 1 NOT NULL;--> statement-breakpoint
+ALTER TABLE "crypto_charges" ADD COLUMN "tx_hash" text;--> statement-breakpoint
+ALTER TABLE "crypto_charges" ADD COLUMN "amount_received_cents" integer DEFAULT 0 NOT NULL;

package/drizzle/migrations/meta/_journal.json

@@ -113,6 +113,13 @@
       "when": 1742918400000,
       "tag": "0015_callback_url",
       "breakpoints": true
+    },
+    {
+      "idx": 16,
+      "version": "7",
+      "when": 1743004800000,
+      "tag": "0016_charge_progress_columns",
+      "breakpoints": true
     }
   ]
 }

package/package.json

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

package/src/billing/crypto/__tests__/unified-checkout.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from "vitest";
+import type { CryptoServiceClient } from "../client.js";
+import { createUnifiedCheckout, MIN_CHECKOUT_USD } from "../unified-checkout.js";
+
+function mockCryptoService(): CryptoServiceClient {
+  return {
+    createCharge: vi.fn().mockResolvedValue({
+      chargeId: "btc:bc1qtest",
+      address: "bc1qtest",
+      chain: "bitcoin",
+      token: "BTC",
+      amountUsd: 50,
+      displayAmount: "0.00076923 BTC",
+      derivationIndex: 7,
+      expiresAt: "2026-03-21T23:00:00Z",
+    }),
+    listChains: vi.fn(),
+    deriveAddress: vi.fn(),
+    getCharge: vi.fn(),
+  } as unknown as CryptoServiceClient;
+}
+
+describe("createUnifiedCheckout", () => {
+  it("delegates to CryptoServiceClient.createCharge", async () => {
+    const service = mockCryptoService();
+    const result = await createUnifiedCheckout({ cryptoService: service }, "btc", { tenant: "t-1", amountUsd: 50 });
+
+    expect(result.depositAddress).toBe("bc1qtest");
+    expect(result.displayAmount).toBe("0.00076923 BTC");
+    expect(result.amountUsd).toBe(50);
+    expect(result.token).toBe("BTC");
+    expect(result.chain).toBe("bitcoin");
+    expect(result.referenceId).toBe("btc:bc1qtest");
+
+    expect(service.createCharge).toHaveBeenCalledWith({
+      chain: "btc",
+      amountUsd: 50,
+      callbackUrl: undefined,
+    });
+  });
+
+  it("passes callbackUrl to createCharge", async () => {
+    const service = mockCryptoService();
+    await createUnifiedCheckout({ cryptoService: service }, "base-usdc", {
+      tenant: "t-1",
+      amountUsd: 25,
+      callbackUrl: "https://example.com/hook",
+    });
+
+    expect(service.createCharge).toHaveBeenCalledWith({
+      chain: "base-usdc",
+      amountUsd: 25,
+      callbackUrl: "https://example.com/hook",
+    });
+  });
+
+  it("rejects amount below minimum", async () => {
+    const service = mockCryptoService();
+    await expect(
+      createUnifiedCheckout({ cryptoService: service }, "btc", { tenant: "t-1", amountUsd: 5 }),
+    ).rejects.toThrow(`Minimum payment amount is $${MIN_CHECKOUT_USD}`);
+
+    expect(service.createCharge).not.toHaveBeenCalled();
+  });
+
+  it("rejects non-finite amount", async () => {
+    const service = mockCryptoService();
+    await expect(
+      createUnifiedCheckout({ cryptoService: service }, "btc", { tenant: "t-1", amountUsd: NaN }),
+    ).rejects.toThrow(`Minimum payment amount is $${MIN_CHECKOUT_USD}`);
+  });
+
+  it("propagates createCharge errors", async () => {
+    const service = mockCryptoService();
+    (service.createCharge as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error("CryptoService createCharge failed (500): Internal Server Error"),
+    );
+
+    await expect(
+      createUnifiedCheckout({ cryptoService: service }, "btc", { tenant: "t-1", amountUsd: 50 }),
+    ).rejects.toThrow("CryptoService createCharge failed (500)");
+  });
+});