diff --git a/src/app/Providers/Payment/Stripe.php b/src/app/Providers/Payment/Stripe.php
index cbde016b..00b0fa75 100644
--- a/src/app/Providers/Payment/Stripe.php
+++ b/src/app/Providers/Payment/Stripe.php
@@ -1,465 +1,465 @@
 <?php
 
 namespace App\Providers\Payment;
 
 use App\Payment;
 use App\Utils;
 use App\Wallet;
 use App\WalletSetting;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Request;
 use Stripe as StripeAPI;
 
 class Stripe extends \App\Providers\PaymentProvider
 {
     /**
      * Class constructor.
      */
     public function __construct()
     {
         StripeAPI\Stripe::setApiKey(\config('services.stripe.key'));
     }
 
     /**
      * Get a link to the customer in the provider's control panel
      *
      * @param \App\Wallet $wallet The wallet
      *
      * @return string|null The string representing <a> tag
      */
     public function customerLink(Wallet $wallet): ?string
     {
         $customer_id = self::stripeCustomerId($wallet, false);
 
         if (!$customer_id) {
             return null;
         }
 
         $location = 'https://dashboard.stripe.com';
 
         $key = \config('services.stripe.key');
 
         if (strpos($key, 'sk_test_') === 0) {
             $location .= '/test';
         }
 
         return sprintf(
             '<a href="%s/customers/%s" target="_blank">%s</a>',
             $location,
             $customer_id,
             $customer_id
         );
     }
 
     /**
      * Create a new auto-payment mandate for a wallet.
      *
      * @param \App\Wallet $wallet  The wallet
      * @param array       $payment Payment data:
      *                             - amount: Value in cents
      *                             - currency: The operation currency
      *                             - description: Operation desc.
      *
      * @return array Provider payment/session data:
      *               - id: Session identifier
      */
     public function createMandate(Wallet $wallet, array $payment): ?array
     {
         // Register the user in Stripe, if not yet done
         $customer_id = self::stripeCustomerId($wallet, true);
 
         $request = [
             'customer' => $customer_id,
-            'cancel_url' => \url('/wallet'), // required
-            'success_url' => \url('/wallet'), // required
+            'cancel_url' => Utils::serviceUrl('/wallet'), // required
+            'success_url' => Utils::serviceUrl('/wallet'), // required
             'payment_method_types' => ['card'], // required
             'locale' => 'en',
             'mode' => 'setup',
         ];
 
         $session = StripeAPI\Checkout\Session::create($request);
 
         $payment = [
             'id' => $session->setup_intent,
             'type' => self::TYPE_MANDATE,
         ];
 
         $this->storePayment($payment, $wallet->id);
 
         return [
             'id' => $session->id,
         ];
     }
 
     /**
      * Revoke the auto-payment mandate.
      *
      * @param \App\Wallet $wallet The wallet
      *
      * @return bool True on success, False on failure
      */
     public function deleteMandate(Wallet $wallet): bool
     {
         // Get the Mandate info
         $mandate = self::stripeMandate($wallet);
 
         if ($mandate) {
             // Remove the reference
             $wallet->setSetting('stripe_mandate_id', null);
 
             // Detach the payment method on Stripe
             $pm = StripeAPI\PaymentMethod::retrieve($mandate->payment_method);
             $pm->detach();
         }
 
         return true;
     }
 
     /**
      * Get a auto-payment mandate for a wallet.
      *
      * @param \App\Wallet $wallet The wallet
      *
      * @return array|null Mandate information:
      *                    - id: Mandate identifier
      *                    - method: user-friendly payment method desc.
      *                    - isPending: the process didn't complete yet
      *                    - isValid: the mandate is valid
      */
     public function getMandate(Wallet $wallet): ?array
     {
         // Get the Mandate info
         $mandate = self::stripeMandate($wallet);
 
         if (empty($mandate)) {
             return null;
         }
 
         $pm = StripeAPI\PaymentMethod::retrieve($mandate->payment_method);
 
         $result = [
             'id' => $mandate->id,
             'isPending' => $mandate->status != 'succeeded' && $mandate->status != 'canceled',
             'isValid' => $mandate->status == 'succeeded',
             'method' => self::paymentMethod($pm, 'Unknown method')
         ];
 
         return $result;
     }
 
     /**
      * Get a provider name
      *
      * @return string Provider name
      */
     public function name(): string
     {
         return 'stripe';
     }
 
     /**
      * Create a new payment.
      *
      * @param \App\Wallet $wallet  The wallet
      * @param array       $payment Payment data:
      *                             - amount: Value in cents
      *                             - currency: The operation currency
      *                             - type: first/oneoff/recurring
      *                             - description: Operation desc.
      *
      * @return array Provider payment/session data:
      *               - id: Session identifier
      */
     public function payment(Wallet $wallet, array $payment): ?array
     {
         if ($payment['type'] == self::TYPE_RECURRING) {
             return $this->paymentRecurring($wallet, $payment);
         }
 
         // Register the user in Stripe, if not yet done
         $customer_id = self::stripeCustomerId($wallet, true);
 
         $request = [
             'customer' => $customer_id,
-            'cancel_url' => \url('/wallet'), // required
-            'success_url' => \url('/wallet'), // required
+            'cancel_url' => Utils::serviceUrl('/wallet'), // required
+            'success_url' => Utils::serviceUrl('/wallet'), // required
             'payment_method_types' => ['card'], // required
             'locale' => 'en',
             'line_items' => [
                 [
                     'name' => $payment['description'],
                     'amount' => $payment['amount'],
                     'currency' => \strtolower($payment['currency']),
                     'quantity' => 1,
                 ]
             ]
         ];
 
         $session = StripeAPI\Checkout\Session::create($request);
 
         // Store the payment reference in database
         $payment['id'] = $session->payment_intent;
 
         $this->storePayment($payment, $wallet->id);
 
         return [
             'id' => $session->id,
         ];
     }
 
     /**
      * Create a new automatic payment operation.
      *
      * @param \App\Wallet $wallet  The wallet
      * @param array       $payment Payment data (see self::payment())
      *
      * @return array Provider payment/session data:
      *               - id: Session identifier
      */
     protected function paymentRecurring(Wallet $wallet, array $payment): ?array
     {
         // Check if there's a valid mandate
         $mandate = self::stripeMandate($wallet);
 
         if (empty($mandate)) {
             return null;
         }
 
         $request = [
             'amount' => $payment['amount'],
             'currency' => \strtolower($payment['currency']),
             'description' => $payment['description'],
             'receipt_email' => $wallet->owner->email,
             'customer' => $mandate->customer,
             'payment_method' => $mandate->payment_method,
             'off_session' => true,
             'confirm' => true,
         ];
 
         $intent = StripeAPI\PaymentIntent::create($request);
 
         // Store the payment reference in database
         $payment['id'] = $intent->id;
 
         $this->storePayment($payment, $wallet->id);
 
         return [
             'id' => $payment['id'],
         ];
     }
 
     /**
      * Update payment status (and balance).
      *
      * @return int HTTP response code
      */
     public function webhook(): int
     {
         // We cannot just use php://input as it's already "emptied" by the framework
         // $payload = file_get_contents('php://input');
         $request = Request::instance();
         $payload = $request->getContent();
         $sig_header = $request->header('Stripe-Signature');
 
         // Parse and validate the input
         try {
             $event = StripeAPI\Webhook::constructEvent(
                 $payload,
                 $sig_header,
                 \config('services.stripe.webhook_secret')
             );
         } catch (\Exception $e) {
             // Invalid payload
             return 400;
         }
 
         switch ($event->type) {
             case StripeAPI\Event::PAYMENT_INTENT_CANCELED:
             case StripeAPI\Event::PAYMENT_INTENT_PAYMENT_FAILED:
             case StripeAPI\Event::PAYMENT_INTENT_SUCCEEDED:
                 $intent = $event->data->object; // @phpstan-ignore-line
                 $payment = Payment::find($intent->id);
 
                 if (empty($payment) || $payment->type == self::TYPE_MANDATE) {
                     return 404;
                 }
 
                 switch ($intent->status) {
                     case StripeAPI\PaymentIntent::STATUS_CANCELED:
                         $status = self::STATUS_CANCELED;
                         break;
                     case StripeAPI\PaymentIntent::STATUS_SUCCEEDED:
                         $status = self::STATUS_PAID;
                         break;
                     default:
                         $status = self::STATUS_FAILED;
                 }
 
                 DB::beginTransaction();
 
                 if ($status == self::STATUS_PAID) {
                     // Update the balance, if it wasn't already
                     if ($payment->status != self::STATUS_PAID) {
                         $this->creditPayment($payment, $intent);
                     }
                 } else {
                     if (!empty($intent->last_payment_error)) {
                         // See https://stripe.com/docs/error-codes for more info
                         \Log::info(sprintf(
                             'Stripe payment failed (%s): %s',
                             $payment->id,
                             json_encode($intent->last_payment_error)
                         ));
                     }
                 }
 
                 if ($payment->status != self::STATUS_PAID) {
                     $payment->status = $status;
                     $payment->save();
 
                     if ($status != self::STATUS_CANCELED && $payment->type == self::TYPE_RECURRING) {
                         // Disable the mandate
                         if ($status == self::STATUS_FAILED) {
                             $payment->wallet->setSetting('mandate_disabled', 1);
                         }
 
                         // Notify the user
                         \App\Jobs\PaymentEmail::dispatch($payment);
                     }
                 }
 
                 DB::commit();
 
                 break;
 
             case StripeAPI\Event::SETUP_INTENT_SUCCEEDED:
             case StripeAPI\Event::SETUP_INTENT_SETUP_FAILED:
             case StripeAPI\Event::SETUP_INTENT_CANCELED:
                 $intent = $event->data->object; // @phpstan-ignore-line
                 $payment = Payment::find($intent->id);
 
                 if (empty($payment) || $payment->type != self::TYPE_MANDATE) {
                     return 404;
                 }
 
                 switch ($intent->status) {
                     case StripeAPI\SetupIntent::STATUS_CANCELED:
                         $status = self::STATUS_CANCELED;
                         break;
                     case StripeAPI\SetupIntent::STATUS_SUCCEEDED:
                         $status = self::STATUS_PAID;
                         break;
                     default:
                         $status = self::STATUS_FAILED;
                 }
 
                 if ($status == self::STATUS_PAID) {
                     $payment->wallet->setSetting('stripe_mandate_id', $intent->id);
                 }
 
                 $payment->status = $status;
                 $payment->save();
 
                 break;
 
             default:
                 \Log::debug("Unhandled Stripe event: " . var_export($payload, true));
                 break;
         }
 
         return 200;
     }
 
     /**
      * Get Stripe customer identifier for specified wallet.
      * Create one if does not exist yet.
      *
      * @param \App\Wallet $wallet The wallet
      * @param bool        $create Create the customer if does not exist yet
      *
      * @return string|null Stripe customer identifier
      */
     protected static function stripeCustomerId(Wallet $wallet, bool $create = false): ?string
     {
         $customer_id = $wallet->getSetting('stripe_id');
 
         // Register the user in Stripe
         if (empty($customer_id) && $create) {
             $customer = StripeAPI\Customer::create([
                     'name'  => $wallet->owner->name(),
                     // Stripe will display the email on Checkout page, editable,
                     // and use it to send the receipt (?), use the user email here
                     // 'email' => $wallet->id . '@private.' . \config('app.domain'),
                     'email' => $wallet->owner->email,
             ]);
 
             $customer_id = $customer->id;
 
             $wallet->setSetting('stripe_id', $customer->id);
         }
 
         return $customer_id;
     }
 
     /**
      * Get the active Stripe auto-payment mandate (Setup Intent)
      */
     protected static function stripeMandate(Wallet $wallet)
     {
         // Note: Stripe also has 'Mandate' objects, but we do not use these
 
         if ($mandate_id = $wallet->getSetting('stripe_mandate_id')) {
             $mandate = StripeAPI\SetupIntent::retrieve($mandate_id);
             // @phpstan-ignore-next-line
             if ($mandate && $mandate->status != 'canceled') {
                 return $mandate;
             }
         }
     }
 
     /**
      * Apply the successful payment's pecunia to the wallet
      */
     protected static function creditPayment(Payment $payment, $intent)
     {
         $method = 'Stripe';
 
         // Extract the payment method for transaction description
         if (
             !empty($intent->charges)
             && ($charge = $intent->charges->data[0])
             && ($pm = $charge->payment_method_details)
         ) {
             $method = self::paymentMethod($pm);
         }
 
         // TODO: Localization?
         $description = $payment->type == self::TYPE_RECURRING ? 'Auto-payment' : 'Payment';
         $description .= " transaction {$payment->id} using {$method}";
 
         $payment->wallet->credit($payment->amount, $description);
 
         // Unlock the disabled auto-payment mandate
         if ($payment->wallet->balance >= 0) {
             $payment->wallet->setSetting('mandate_disabled', null);
         }
     }
 
     /**
      * Extract payment method description from Stripe payment details
      */
     protected static function paymentMethod($details, $default = ''): string
     {
         switch ($details->type) {
             case 'card':
                 // TODO: card number
                 return \sprintf(
                     '%s (**** **** **** %s)',
                     \ucfirst($details->card->brand) ?: 'Card',
                     $details->card->last4
                 );
         }
 
         return $default;
     }
 }
diff --git a/src/app/Utils.php b/src/app/Utils.php
index f3f26658..1f48f22b 100644
--- a/src/app/Utils.php
+++ b/src/app/Utils.php
@@ -1,159 +1,152 @@
 <?php
 
 namespace App;
 
 use Carbon\Carbon;
 use Illuminate\Support\Facades\Auth;
 use Ramsey\Uuid\Uuid;
 
 /**
  * Small utility functions for App.
  */
 class Utils
 {
     /**
      * Return the number of days in the month prior to this one.
      *
      * @return int
      */
     public static function daysInLastMonth()
     {
         $start = new Carbon('first day of last month');
         $end = new Carbon('last day of last month');
 
         return $start->diffInDays($end) + 1;
     }
 
     /**
      * Provide all unique combinations of elements in $input, with order and duplicates irrelevant.
      *
      * @param array $input The input array of elements.
      *
      * @return array[]
      */
     public static function powerSet(array $input): array
     {
         $output = [];
 
         for ($x = 0; $x < count($input); $x++) {
             self::combine($input, $x + 1, 0, [], 0, $output);
         }
 
         return $output;
     }
 
     /**
      * Returns the current user's email address or null.
      *
      * @return string
      */
     public static function userEmailOrNull(): ?string
     {
         $user = Auth::user();
 
         if (!$user) {
             return null;
         }
 
         return $user->email;
     }
 
     /**
      * Returns a UUID in the form of an integer.
      *
      * @return integer
      */
     public static function uuidInt(): int
     {
         $hex = Uuid::uuid4();
         $bin = pack('h*', str_replace('-', '', $hex));
         $ids = unpack('L', $bin);
         $id = array_shift($ids);
 
         return $id;
     }
 
     /**
      * Returns a UUID in the form of a string.
      *
      * @return string
      */
     public static function uuidStr(): string
     {
         return Uuid::uuid4()->toString();
     }
 
     private static function combine($input, $r, $index, $data, $i, &$output): void
     {
         $n = count($input);
 
         // Current cobination is ready
         if ($index == $r) {
             $output[] = array_slice($data, 0, $r);
             return;
         }
 
         // When no more elements are there to put in data[]
         if ($i >= $n) {
             return;
         }
 
         // current is included, put next at next location
         $data[$index] = $input[$i];
         self::combine($input, $r, $index + 1, $data, $i + 1, $output);
 
         // current is excluded, replace it with next (Note that i+1
         // is passed, but index is not changed)
         self::combine($input, $r, $index, $data, $i + 1, $output);
     }
 
     /**
      * Create self URL
      *
      * @param string $route Route/Path
      *
      * @return string Full URL
      */
     public static function serviceUrl(string $route): string
     {
-        return trim(\config('app.public_url'), '/') . '/' . ltrim($route, '/');
+        $url = \config('app.public_url');
 
-        // TODO: Investigate why it does not work
-
-        $url = \secure_url($route);
-
-        $app_url = trim(\config('app.url'), '/');
-        $pub_url = trim(\config('app.public_url'), '/');
-
-        if ($pub_url != $app_url) {
-            $url = str_replace($app_url, $pub_url, $url);
+        if (!$url) {
+            $url = \config('app.url');
         }
 
-        return $url;
+        return rtrim(trim($url, '/') . '/' . ltrim($route, '/'), '/');
     }
 
     /**
      * Create a configuration/environment data to be passed to
      * the UI
      *
      * @todo For a lack of better place this is put here for now
      *
      * @return array Configuration data
      */
     public static function uiEnv(): array
     {
         $opts = ['app.name', 'app.url', 'app.domain'];
         $env = \app('config')->getMany($opts);
 
         $countries = include resource_path('countries.php');
         $env['countries'] = $countries ?: [];
 
         $isAdmin = strpos(request()->getHttpHost(), 'admin.') === 0;
         $env['jsapp'] = $isAdmin ? 'admin.js' : 'user.js';
 
         $env['paymentProvider'] = \config('services.payment_provider');
         $env['stripePK'] = \config('services.stripe.public_key');
 
         return $env;
     }
 }
diff --git a/src/tests/Unit/UtilsTest.php b/src/tests/Unit/UtilsTest.php
index 7f10ef3b..9771f36e 100644
--- a/src/tests/Unit/UtilsTest.php
+++ b/src/tests/Unit/UtilsTest.php
@@ -1,83 +1,104 @@
 <?php
 
 namespace Tests\Unit;
 
 use App\Utils;
 use Tests\TestCase;
 
 class UtilsTest extends TestCase
 {
     /**
      * Test for Utils::powerSet()
-     *
-     * @return void
      */
-    public function testPowerSet()
+    public function testPowerSet(): void
     {
         $set = [];
 
         $result = \App\Utils::powerSet($set);
 
         $this->assertIsArray($result);
         $this->assertCount(0, $result);
 
         $set = ["a1"];
 
         $result = \App\Utils::powerSet($set);
 
         $this->assertIsArray($result);
         $this->assertCount(1, $result);
         $this->assertTrue(in_array(["a1"], $result));
 
         $set = ["a1", "a2"];
 
         $result = \App\Utils::powerSet($set);
 
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertTrue(in_array(["a1"], $result));
         $this->assertTrue(in_array(["a2"], $result));
         $this->assertTrue(in_array(["a1", "a2"], $result));
 
         $set = ["a1", "a2", "a3"];
 
         $result = \App\Utils::powerSet($set);
 
         $this->assertIsArray($result);
         $this->assertCount(7, $result);
         $this->assertTrue(in_array(["a1"], $result));
         $this->assertTrue(in_array(["a2"], $result));
         $this->assertTrue(in_array(["a3"], $result));
         $this->assertTrue(in_array(["a1", "a2"], $result));
         $this->assertTrue(in_array(["a1", "a3"], $result));
         $this->assertTrue(in_array(["a2", "a3"], $result));
         $this->assertTrue(in_array(["a1", "a2", "a3"], $result));
     }
 
+    /**
+     * Test for Utils::serviceUrl()
+     */
+    public function testServiceUrl(): void
+    {
+        $public_href = 'https://public.url/cockpit';
+        $local_href = 'https://local.url/cockpit';
+
+        \config([
+            'app.url' => $local_href,
+            'app.public_url' => '',
+        ]);
+
+        $this->assertSame($local_href, Utils::serviceUrl(''));
+        $this->assertSame($local_href . '/unknown', Utils::serviceUrl('unknown'));
+        $this->assertSame($local_href . '/unknown', Utils::serviceUrl('/unknown'));
+
+        \config([
+            'app.url' => $local_href,
+            'app.public_url' => $public_href,
+        ]);
+
+        $this->assertSame($public_href, Utils::serviceUrl(''));
+        $this->assertSame($public_href . '/unknown', Utils::serviceUrl('unknown'));
+        $this->assertSame($public_href . '/unknown', Utils::serviceUrl('/unknown'));
+    }
+
     /**
      * Test for Utils::uuidInt()
-     *
-     * @return void
      */
-    public function testUuidInt()
+    public function testUuidInt(): void
     {
         $result = Utils::uuidInt();
 
         $this->assertTrue(is_int($result));
         $this->assertTrue($result > 0);
     }
 
     /**
      * Test for Utils::uuidStr()
-     *
-     * @return void
      */
-    public function testUuidStr()
+    public function testUuidStr(): void
     {
         $result = Utils::uuidStr();
 
         $this->assertTrue(is_string($result));
         $this->assertTrue(strlen($result) === 36);
         $this->assertTrue(preg_match('/[^a-f0-9-]/i', $result) === 0);
     }
 }