diff --git a/src/app/Http/Controllers/API/V4/PaymentsController.php b/src/app/Http/Controllers/API/V4/PaymentsController.php
index 58a59ce6..e46b8f88 100644
--- a/src/app/Http/Controllers/API/V4/PaymentsController.php
+++ b/src/app/Http/Controllers/API/V4/PaymentsController.php
@@ -1,328 +1,475 @@
 <?php
 
 namespace App\Http\Controllers\API\V4;
 
 use App\Http\Controllers\Controller;
 use App\Providers\PaymentProvider;
 use App\Wallet;
+use App\Payment;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Validator;
 
 class PaymentsController extends Controller
 {
     /**
      * Get the auto-payment mandate info.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function mandate()
     {
         $user = Auth::guard()->user();
 
         // TODO: Wallet selection
         $wallet = $user->wallets()->first();
 
         $mandate = self::walletMandate($wallet);
 
         return response()->json($mandate);
     }
 
     /**
      * Create a new auto-payment mandate.
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function mandateCreate(Request $request)
     {
         $current_user = Auth::guard()->user();
 
         // TODO: Wallet selection
         $wallet = $current_user->wallets()->first();
 
         // Input validation
         if ($errors = self::mandateValidate($request, $wallet)) {
             return response()->json(['status' => 'error', 'errors' => $errors], 422);
         }
 
         $wallet->setSettings([
                 'mandate_amount' => $request->amount,
                 'mandate_balance' => $request->balance,
         ]);
 
         $mandate = [
             'currency' => 'CHF',
             'description' => \config('app.name') . ' Auto-Payment Setup',
+            'methodId' => $request->methodId
         ];
 
         // Normally the auto-payment setup operation is 0, if the balance is below the threshold
         // we'll top-up the wallet with the configured auto-payment amount
         if ($wallet->balance < intval($request->balance * 100)) {
             $mandate['amount'] = intval($request->amount * 100);
         }
 
         $provider = PaymentProvider::factory($wallet);
 
         $result = $provider->createMandate($wallet, $mandate);
 
         $result['status'] = 'success';
 
         return response()->json($result);
     }
 
     /**
      * Revoke the auto-payment mandate.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function mandateDelete()
     {
         $user = Auth::guard()->user();
 
         // TODO: Wallet selection
         $wallet = $user->wallets()->first();
 
         $provider = PaymentProvider::factory($wallet);
 
         $provider->deleteMandate($wallet);
 
         $wallet->setSetting('mandate_disabled', null);
 
         return response()->json([
                 'status' => 'success',
                 'message' => \trans('app.mandate-delete-success'),
         ]);
     }
 
     /**
      * Update a new auto-payment mandate.
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function mandateUpdate(Request $request)
     {
         $current_user = Auth::guard()->user();
 
         // TODO: Wallet selection
         $wallet = $current_user->wallets()->first();
 
         // Input validation
         if ($errors = self::mandateValidate($request, $wallet)) {
             return response()->json(['status' => 'error', 'errors' => $errors], 422);
         }
 
         $wallet->setSettings([
                 'mandate_amount' => $request->amount,
                 'mandate_balance' => $request->balance,
                 // Re-enable the mandate to give it a chance to charge again
                 // after it has been disabled (e.g. because the mandate amount was too small)
                 'mandate_disabled' => null,
         ]);
 
         // Trigger auto-payment if the balance is below the threshold
         if ($wallet->balance < intval($request->balance * 100)) {
             \App\Jobs\WalletCharge::dispatch($wallet);
         }
 
         $result = self::walletMandate($wallet);
         $result['status'] = 'success';
         $result['message'] = \trans('app.mandate-update-success');
 
         return response()->json($result);
     }
 
     /**
      * Validate an auto-payment mandate request.
      *
      * @param \Illuminate\Http\Request $request The API request.
      * @param \App\Wallet              $wallet  The wallet
      *
      * @return array|null List of errors on error or Null on success
      */
     protected static function mandateValidate(Request $request, Wallet $wallet)
     {
         $rules = [
             'amount' => 'required|numeric',
             'balance' => 'required|numeric|min:0',
         ];
 
         // Check required fields
         $v = Validator::make($request->all(), $rules);
 
         // TODO: allow comma as a decimal point?
 
         if ($v->fails()) {
             return $v->errors()->toArray();
         }
 
         $amount = (int) ($request->amount * 100);
 
         // Validate the minimum value
         // It has to be at least minimum payment amount and must cover current debt
         if (
             $wallet->balance < 0
             && $wallet->balance * -1 > PaymentProvider::MIN_AMOUNT
             && $wallet->balance + $amount < 0
         ) {
             return ['amount' => \trans('validation.minamountdebt')];
         }
 
         if ($amount < PaymentProvider::MIN_AMOUNT) {
             $min = intval(PaymentProvider::MIN_AMOUNT / 100) . ' CHF';
             return ['amount' => \trans('validation.minamount', ['amount' => $min])];
         }
 
         return null;
     }
 
     /**
      * Create a new payment.
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function store(Request $request)
     {
         $current_user = Auth::guard()->user();
 
         // TODO: Wallet selection
         $wallet = $current_user->wallets()->first();
 
         $rules = [
             'amount' => 'required|numeric',
         ];
 
         // Check required fields
         $v = Validator::make($request->all(), $rules);
 
         // TODO: allow comma as a decimal point?
 
         if ($v->fails()) {
             return response()->json(['status' => 'error', 'errors' => $v->errors()], 422);
         }
 
         $amount = (int) ($request->amount * 100);
 
         // Validate the minimum value
         if ($amount < PaymentProvider::MIN_AMOUNT) {
             $min = intval(PaymentProvider::MIN_AMOUNT / 100) . ' CHF';
             $errors = ['amount' => \trans('validation.minamount', ['amount' => $min])];
             return response()->json(['status' => 'error', 'errors' => $errors], 422);
         }
 
         $request = [
             'type' => PaymentProvider::TYPE_ONEOFF,
-            'currency' => 'CHF',
+            'currency' => $request->currency,
             'amount' => $amount,
+            'methodId' => $request->methodId,
             'description' => \config('app.name') . ' Payment',
         ];
 
         $provider = PaymentProvider::factory($wallet);
 
         $result = $provider->payment($wallet, $request);
 
         $result['status'] = 'success';
 
         return response()->json($result);
     }
 
+    /**
+     * Delete a pending payment.
+     *
+     * @param \Illuminate\Http\Request $request The API request.
+     *
+     * @return \Illuminate\Http\JsonResponse The response
+     */
+    // TODO currently unused
+    // public function cancel(Request $request)
+    // {
+    //     $current_user = Auth::guard()->user();
+
+    //     // TODO: Wallet selection
+    //     $wallet = $current_user->wallets()->first();
+
+    //     $paymentId = $request->payment;
+
+    //     $user_owns_payment = Payment::where('id', $paymentId)
+    //         ->where('wallet_id', $wallet->id)
+    //         ->exists();
+
+    //     if (!$user_owns_payment) {
+    //         return $this->errorResponse(404);
+    //     }
+
+    //     $provider = PaymentProvider::factory($wallet);
+    //     if ($provider->cancel($wallet, $paymentId)) {
+    //         $result = ['status' => 'success'];
+    //         return response()->json($result);
+    //     }
+
+    //     return $this->errorResponse(404);
+    // }
+
     /**
      * Update payment status (and balance).
      *
      * @param string $provider Provider name
      *
      * @return \Illuminate\Http\Response The response
      */
     public function webhook($provider)
     {
         $code = 200;
 
         if ($provider = PaymentProvider::factory($provider)) {
             $code = $provider->webhook();
         }
 
         return response($code < 400 ? 'Success' : 'Server error', $code);
     }
 
     /**
      * Top up a wallet with a "recurring" payment.
      *
      * @param \App\Wallet $wallet The wallet to charge
      *
      * @return bool True if the payment has been initialized
      */
     public static function topUpWallet(Wallet $wallet): bool
     {
         if ((bool) $wallet->getSetting('mandate_disabled')) {
             return false;
         }
 
         $min_balance = (int) (floatval($wallet->getSetting('mandate_balance')) * 100);
         $amount = (int) (floatval($wallet->getSetting('mandate_amount')) * 100);
 
         // The wallet balance is greater than the auto-payment threshold
         if ($wallet->balance >= $min_balance) {
             // Do nothing
             return false;
         }
 
         $provider = PaymentProvider::factory($wallet);
         $mandate = (array) $provider->getMandate($wallet);
 
         if (empty($mandate['isValid'])) {
             return false;
         }
 
         // The defined top-up amount is not enough
         // Disable auto-payment and notify the user
         if ($wallet->balance + $amount < 0) {
             // Disable (not remove) the mandate
             $wallet->setSetting('mandate_disabled', 1);
             \App\Jobs\PaymentMandateDisabledEmail::dispatch($wallet);
             return false;
         }
 
         $request = [
             'type' => PaymentProvider::TYPE_RECURRING,
             'currency' => 'CHF',
             'amount' => $amount,
+            'methodId' => PaymentProvider::METHOD_CREDITCARD,
             'description' => \config('app.name') . ' Recurring Payment',
         ];
 
         $result = $provider->payment($wallet, $request);
 
         return !empty($result);
     }
 
     /**
      * Returns auto-payment mandate info for the specified wallet
      *
      * @param \App\Wallet $wallet A wallet object
      *
      * @return array A mandate metadata
      */
     public static function walletMandate(Wallet $wallet): array
     {
         $provider = PaymentProvider::factory($wallet);
 
         // Get the Mandate info
         $mandate = (array) $provider->getMandate($wallet);
 
         $mandate['amount'] = (int) (PaymentProvider::MIN_AMOUNT / 100);
         $mandate['balance'] = 0;
         $mandate['isDisabled'] = !empty($mandate['id']) && $wallet->getSetting('mandate_disabled');
 
         foreach (['amount', 'balance'] as $key) {
             if (($value = $wallet->getSetting("mandate_{$key}")) !== null) {
                 $mandate[$key] = $value;
             }
         }
 
         return $mandate;
     }
+
+
+    /**
+     * List supported payment methods.
+     *
+     * @param \Illuminate\Http\Request $request The API request.
+     *
+     * @return \Illuminate\Http\JsonResponse The response
+     */
+    public static function paymentMethods(Request $request)
+    {
+        $user = Auth::guard()->user();
+
+        // TODO: Wallet selection
+        $wallet = $user->wallets()->first();
+
+        $methods = PaymentProvider::paymentMethods($wallet, $request->type);
+
+        \Log::debug("Provider methods" . var_export(json_encode($methods), true));
+
+        return response()->json($methods);
+    }
+
+    /**
+     * Check for pending payments.
+     *
+     * @param \Illuminate\Http\Request $request The API request.
+     *
+     * @return \Illuminate\Http\JsonResponse The response
+     */
+    public static function hasPayments(Request $request)
+    {
+        $user = Auth::guard()->user();
+
+        // TODO: Wallet selection
+        $wallet = $user->wallets()->first();
+
+        $exists = Payment::where('wallet_id', $wallet->id)
+            ->where('type', PaymentProvider::TYPE_ONEOFF)
+            ->whereIn('status', [
+                PaymentProvider::STATUS_OPEN,
+                PaymentProvider::STATUS_PENDING,
+                PaymentProvider::STATUS_AUTHORIZED])
+            ->exists();
+
+        return response()->json([
+            'status' => 'success',
+            'hasPending' => $exists
+        ]);
+    }
+
+    /**
+     * List pending payments.
+     *
+     * @param \Illuminate\Http\Request $request The API request.
+     *
+     * @return \Illuminate\Http\JsonResponse The response
+     */
+    public static function payments(Request $request)
+    {
+        $user = Auth::guard()->user();
+
+        // TODO: Wallet selection
+        $wallet = $user->wallets()->first();
+
+        $pageSize = 10;
+        $page = intval(request()->input('page')) ?: 1;
+        $hasMore = false;
+        $result = Payment::where('wallet_id', $wallet->id)
+            ->where('type', PaymentProvider::TYPE_ONEOFF)
+            ->whereIn('status', [
+                PaymentProvider::STATUS_OPEN,
+                PaymentProvider::STATUS_PENDING,
+                PaymentProvider::STATUS_AUTHORIZED])
+            ->orderBy('created_at', 'desc')
+            ->limit($pageSize + 1)
+            ->offset($pageSize * ($page - 1))
+            ->get();
+
+        if (count($result) > $pageSize) {
+            $result->pop();
+            $hasMore = true;
+        }
+
+        $result = $result->map(function ($item) {
+            $provider = PaymentProvider::factory($item->provider);
+            $payment = $provider->getPayment($item->id);
+            $entry = [
+                'id' => $item->id,
+                'createdAt' => $item->created_at->format('Y-m-d H:i'),
+                'type' => $item->type,
+                'description' => $item->description,
+                'amount' => $item->amount,
+                'status' => $item->status,
+                'isCancelable' => $payment['isCancelable'],
+                'checkoutUrl' => $payment['checkoutUrl']
+            ];
+
+            return $entry;
+        });
+
+        return response()->json([
+            'status' => 'success',
+            'list' => $result,
+            'count' => count($result),
+            'hasMore' => $hasMore,
+            'page' => $page,
+        ]);
+    }
 }
diff --git a/src/app/Payment.php b/src/app/Payment.php
index f501decc..ba088b68 100644
--- a/src/app/Payment.php
+++ b/src/app/Payment.php
@@ -1,48 +1,61 @@
 <?php
 
 namespace App;
 
 use Illuminate\Database\Eloquent\Model;
 
 /**
  * A payment operation on a wallet.
  *
- * @property int         $amount      Amount of money in cents
+ * @property int         $amount      Amount of money in cents of CHF
  * @property string      $description Payment description
  * @property string      $id          Mollie's Payment ID
  * @property \App\Wallet $wallet      The wallet
  * @property string      $wallet_id   The ID of the wallet
+ * @property string      $currency    Currency of this payment
+ * @property int         $currency_amount      Amount of money in cents of $currency
  */
 class Payment extends Model
 {
     public $incrementing = false;
     protected $keyType = 'string';
 
     protected $casts = [
         'amount' => 'integer'
     ];
 
     protected $fillable = [
         'id',
         'wallet_id',
         'amount',
         'description',
         'provider',
         'status',
         'type',
+        'currency',
+        'currency_amount',
     ];
 
+
+    /**
+     * Ensure the currency is appropriately cased.
+     */
+    public function setCurrencyAttribute($currency)
+    {
+        $this->attributes['currency'] = strtoupper($currency);
+    }
+
     /**
      * The wallet to which this payment belongs.
      *
      * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
      */
     public function wallet()
     {
         return $this->belongsTo(
             '\App\Wallet',
             'wallet_id', /* local */
             'id' /* remote */
         );
     }
 }
diff --git a/src/app/Providers/Payment/Mollie.php b/src/app/Providers/Payment/Mollie.php
index 450af342..bdbf867a 100644
--- a/src/app/Providers/Payment/Mollie.php
+++ b/src/app/Providers/Payment/Mollie.php
@@ -1,513 +1,622 @@
 <?php
 
 namespace App\Providers\Payment;
 
 use App\Payment;
 use App\Utils;
 use App\Wallet;
 use Illuminate\Support\Facades\DB;
 use Mollie\Api\Exceptions\ApiException;
 use Mollie\Api\Types;
 
 class Mollie extends \App\Providers\PaymentProvider
 {
     /**
      * 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::mollieCustomerId($wallet, false);
 
         if (!$customer_id) {
             return null;
         }
 
         return sprintf(
             '<a href="https://www.mollie.com/dashboard/customers/%s" target="_blank">%s</a>',
             $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 (optional)
      *                             - currency: The operation currency
      *                             - description: Operation desc.
+     *                             - methodId: Payment method
      *
      * @return array Provider payment data:
      *               - id: Operation identifier
      *               - redirectUrl: the location to redirect to
      */
     public function createMandate(Wallet $wallet, array $payment): ?array
     {
         // Register the user in Mollie, if not yet done
         $customer_id = self::mollieCustomerId($wallet, true);
 
         if (!isset($payment['amount'])) {
             $payment['amount'] = 0;
         }
 
+        $amount = $this->exchange($payment['amount'], $wallet->currency, $payment['currency']);
+        $payment['currency_amount'] = $amount;
+
         $request = [
             'amount' => [
                 'currency' => $payment['currency'],
-                'value' => sprintf('%.2f', $payment['amount'] / 100),
+                'value' => sprintf('%.2f', $amount / 100),
             ],
             'customerId' => $customer_id,
             'sequenceType' => 'first',
             'description' => $payment['description'],
             'webhookUrl' => Utils::serviceUrl('/api/webhooks/payment/mollie'),
             'redirectUrl' => Utils::serviceUrl('/wallet'),
             'locale' => 'en_US',
-            // 'method' => 'creditcard',
+            'method' => $payment['methodId']
         ];
 
         // Create the payment in Mollie
         $response = mollie()->payments()->create($request);
 
         if ($response->mandateId) {
             $wallet->setSetting('mollie_mandate_id', $response->mandateId);
         }
 
         // Store the payment reference in database
         $payment['status'] = $response->status;
         $payment['id'] = $response->id;
         $payment['type'] = self::TYPE_MANDATE;
 
         $this->storePayment($payment, $wallet->id);
 
         return [
             'id' => $response->id,
             'redirectUrl' => $response->getCheckoutUrl(),
         ];
     }
 
     /**
      * Revoke the auto-payment mandate for the wallet.
      *
      * @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::mollieMandate($wallet);
 
         // Revoke the mandate on Mollie
         if ($mandate) {
             $mandate->revoke();
 
             $wallet->setSetting('mollie_mandate_id', null);
         }
 
         return true;
     }
 
     /**
      * Get a auto-payment mandate for the wallet.
      *
      * @param \App\Wallet $wallet The wallet
      *
      * @return array|null Mandate information:
      *                    - id: Mandate identifier
      *                    - method: user-friendly payment method desc.
+     *                    - methodId: Payment method
      *                    - isPending: the process didn't complete yet
      *                    - isValid: the mandate is valid
      */
     public function getMandate(Wallet $wallet): ?array
     {
         // Get the Mandate info
         $mandate = self::mollieMandate($wallet);
 
         if (empty($mandate)) {
             return null;
         }
 
         $result = [
             'id' => $mandate->id,
             'isPending' => $mandate->isPending(),
             'isValid' => $mandate->isValid(),
-            'method' => self::paymentMethod($mandate, 'Unknown method')
+            'method' => self::paymentMethod($mandate, 'Unknown method'),
+            'methodId' => $mandate->method
         ];
 
         return $result;
     }
 
     /**
      * Get a provider name
      *
      * @return string Provider name
      */
     public function name(): string
     {
         return 'mollie';
     }
 
     /**
      * Create a new payment.
      *
      * @param \App\Wallet $wallet  The wallet
      * @param array       $payment Payment data:
      *                             - amount: Value in cents
      *                             - currency: The operation currency
      *                             - type: oneoff/recurring
      *                             - description: Operation desc.
+     *                             - methodId: Payment method
      *
      * @return array Provider payment data:
      *               - id: Operation identifier
      *               - redirectUrl: the location to redirect to
      */
     public function payment(Wallet $wallet, array $payment): ?array
     {
         if ($payment['type'] == self::TYPE_RECURRING) {
             return $this->paymentRecurring($wallet, $payment);
         }
 
         // Register the user in Mollie, if not yet done
         $customer_id = self::mollieCustomerId($wallet, true);
 
-        // Note: Required fields: description, amount/currency, amount/value
+        $amount = $this->exchange($payment['amount'], $wallet->currency, $payment['currency']);
+        $payment['currency_amount'] = $amount;
 
+        // Note: Required fields: description, amount/currency, amount/value
         $request = [
             'amount' => [
                 'currency' => $payment['currency'],
-                // a number with two decimals is required
-                'value' => sprintf('%.2f', $payment['amount'] / 100),
+                // a number with two decimals is required (note that JPK and ISK don't require decimals,
+                // but we're not using them currently)
+                'value' => sprintf('%.2f', $amount / 100),
             ],
             'customerId' => $customer_id,
             'sequenceType' => $payment['type'],
             'description' => $payment['description'],
             'webhookUrl' => Utils::serviceUrl('/api/webhooks/payment/mollie'),
             'locale' => 'en_US',
-            // 'method' => 'creditcard',
+            'method' => $payment['methodId'],
             'redirectUrl' => Utils::serviceUrl('/wallet') // required for non-recurring payments
         ];
 
         // TODO: Additional payment parameters for better fraud protection:
         //   billingEmail - for bank transfers, Przelewy24, but not creditcard
         //   billingAddress (it is a structured field not just text)
 
         // Create the payment in Mollie
         $response = mollie()->payments()->create($request);
 
         // Store the payment reference in database
         $payment['status'] = $response->status;
         $payment['id'] = $response->id;
 
         $this->storePayment($payment, $wallet->id);
 
         return [
             'id' => $payment['id'],
             'redirectUrl' => $response->getCheckoutUrl(),
         ];
     }
 
+
+    /**
+     * Cancel a pending payment.
+     *
+     * @param \App\Wallet $wallet  The wallet
+     * @param string      $paymentId Payment Id
+     *
+     * @return bool True on success, False on failure
+     */
+    public function cancel(Wallet $wallet, $paymentId): bool
+    {
+        $response = mollie()->payments()->delete($paymentId);
+
+        $db_payment = Payment::find($paymentId);
+        $db_payment->status = $response->status;
+        $db_payment->save();
+
+        return true;
+    }
+
+
     /**
      * 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: Operation identifier
      */
     protected function paymentRecurring(Wallet $wallet, array $payment): ?array
     {
         // Check if there's a valid mandate
         $mandate = self::mollieMandate($wallet);
 
         if (empty($mandate) || !$mandate->isValid() || $mandate->isPending()) {
             return null;
         }
 
         $customer_id = self::mollieCustomerId($wallet, true);
 
         // Note: Required fields: description, amount/currency, amount/value
+        $amount = $this->exchange($payment['amount'], $wallet->currency, $payment['currency']);
+        $payment['currency_amount'] = $amount;
 
         $request = [
             'amount' => [
                 'currency' => $payment['currency'],
                 // a number with two decimals is required
-                'value' => sprintf('%.2f', $payment['amount'] / 100),
+                'value' => sprintf('%.2f', $amount / 100),
             ],
             'customerId' => $customer_id,
             'sequenceType' => $payment['type'],
             'description' => $payment['description'],
             'webhookUrl' => Utils::serviceUrl('/api/webhooks/payment/mollie'),
             'locale' => 'en_US',
-            // 'method' => 'creditcard',
+            'method' => $payment['methodId'],
             'mandateId' => $mandate->id
         ];
 
         // Create the payment in Mollie
         $response = mollie()->payments()->create($request);
 
         // Store the payment reference in database
         $payment['status'] = $response->status;
         $payment['id'] = $response->id;
 
         DB::beginTransaction();
 
         $payment = $this->storePayment($payment, $wallet->id);
 
         // Mollie can return 'paid' status immediately, so we don't
         // have to wait for the webhook. What's more, the webhook would ignore
         // the payment because it will be marked as paid before the webhook.
         // Let's handle paid status here too.
         if ($response->isPaid()) {
             self::creditPayment($payment, $response);
             $notify = true;
         } elseif ($response->isFailed()) {
             // Note: I didn't find a way to get any description of the problem with a payment
             \Log::info(sprintf('Mollie payment failed (%s)', $response->id));
 
             // Disable the mandate
             $wallet->setSetting('mandate_disabled', 1);
             $notify = true;
         }
 
         DB::commit();
 
         if (!empty($notify)) {
             \App\Jobs\PaymentEmail::dispatch($payment);
         }
 
         return [
             'id' => $payment['id'],
         ];
     }
 
     /**
      * Update payment status (and balance).
      *
      * @return int HTTP response code
      */
     public function webhook(): int
     {
         $payment_id = \request()->input('id');
 
         if (empty($payment_id)) {
             return 200;
         }
 
         $payment = Payment::find($payment_id);
 
         if (empty($payment)) {
             // Mollie recommends to return "200 OK" even if the payment does not exist
             return 200;
         }
 
         // Get the payment details from Mollie
         // TODO: Consider https://github.com/mollie/mollie-api-php/issues/502 when it's fixed
         $mollie_payment = mollie()->payments()->get($payment_id);
 
         if (empty($mollie_payment)) {
             // Mollie recommends to return "200 OK" even if the payment does not exist
             return 200;
         }
 
         $refunds = [];
 
         if ($mollie_payment->isPaid()) {
             // The payment is paid. Update the balance, and notify the user
             if ($payment->status != self::STATUS_PAID && $payment->amount > 0) {
                 $credit = true;
                 $notify = $payment->type == self::TYPE_RECURRING;
             }
 
             // The payment has been (partially) refunded.
             // Let's process refunds with status "refunded".
             if ($mollie_payment->hasRefunds()) {
                 foreach ($mollie_payment->refunds() as $refund) {
                     if ($refund->isTransferred() && $refund->amount->value) {
                         $refunds[] = [
                             'id' => $refund->id,
                             'description' => $refund->description,
                             'amount' => round(floatval($refund->amount->value) * 100),
                             'type' => self::TYPE_REFUND,
-                            // Note: we assume this is the original payment/wallet currency
+                            'currency' => $refund->amount->currency
                         ];
                     }
                 }
             }
 
             // The payment has been (partially) charged back.
             // Let's process chargebacks (they have no states as refunds)
             if ($mollie_payment->hasChargebacks()) {
                 foreach ($mollie_payment->chargebacks() as $chargeback) {
                     if ($chargeback->amount->value) {
                         $refunds[] = [
                             'id' => $chargeback->id,
                             'amount' => round(floatval($chargeback->amount->value) * 100),
                             'type' => self::TYPE_CHARGEBACK,
-                            // Note: we assume this is the original payment/wallet currency
+                            'currency' => $chargeback->amount->currency
                         ];
                     }
                 }
             }
 
             // In case there were multiple auto-payment setup requests (e.g. caused by a double
             // form submission) we end up with multiple payment records and mollie_mandate_id
             // pointing to the one from the last payment not the successful one.
             // We make sure to use mandate id from the successful "first" payment.
             if (
                 $payment->type == self::TYPE_MANDATE
                 && $mollie_payment->mandateId
                 && $mollie_payment->sequenceType == Types\SequenceType::SEQUENCETYPE_FIRST
             ) {
                 $payment->wallet->setSetting('mollie_mandate_id', $mollie_payment->mandateId);
             }
         } elseif ($mollie_payment->isFailed()) {
             // Note: I didn't find a way to get any description of the problem with a payment
             \Log::info(sprintf('Mollie payment failed (%s)', $payment->id));
 
             // Disable the mandate
             if ($payment->type == self::TYPE_RECURRING) {
                 $notify = true;
                 $payment->wallet->setSetting('mandate_disabled', 1);
             }
         }
 
         DB::beginTransaction();
 
         // This is a sanity check, just in case the payment provider api
         // sent us open -> paid -> open -> paid. So, we lock the payment after
         // recivied a "final" state.
         $pending_states = [self::STATUS_OPEN, self::STATUS_PENDING, self::STATUS_AUTHORIZED];
         if (in_array($payment->status, $pending_states)) {
             $payment->status = $mollie_payment->status;
             $payment->save();
         }
 
         if (!empty($credit)) {
             self::creditPayment($payment, $mollie_payment);
         }
 
         foreach ($refunds as $refund) {
             $this->storeRefund($payment->wallet, $refund);
         }
 
         DB::commit();
 
         if (!empty($notify)) {
             \App\Jobs\PaymentEmail::dispatch($payment);
         }
 
         return 200;
     }
 
     /**
      * Get Mollie 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 Mollie customer identifier
      */
     protected static function mollieCustomerId(Wallet $wallet, bool $create = false): ?string
     {
         $customer_id = $wallet->getSetting('mollie_id');
 
         // Register the user in Mollie
         if (empty($customer_id) && $create) {
             $customer = mollie()->customers()->create([
                     'name'  => $wallet->owner->name(),
                     'email' => $wallet->id . '@private.' . \config('app.domain'),
             ]);
 
             $customer_id = $customer->id;
 
             $wallet->setSetting('mollie_id', $customer->id);
         }
 
         return $customer_id;
     }
 
     /**
      * Get the active Mollie auto-payment mandate
      */
     protected static function mollieMandate(Wallet $wallet)
     {
         $customer_id = $wallet->getSetting('mollie_id');
         $mandate_id = $wallet->getSetting('mollie_mandate_id');
 
         // Get the manadate reference we already have
         if ($customer_id && $mandate_id) {
             try {
                 return mollie()->mandates()->getForId($customer_id, $mandate_id);
             } catch (ApiException $e) {
                 // FIXME: What about 404?
                 if ($e->getCode() == 410) {
                     // The mandate is gone, remove the reference
                     $wallet->setSetting('mollie_mandate_id', null);
                     return null;
                 }
 
                 // TODO: Maybe we shouldn't always throw? It make sense in the job
                 //       but for example when we're just fetching wallet info...
                 throw $e;
             }
         }
     }
 
     /**
      * Apply the successful payment's pecunia to the wallet
      */
     protected static function creditPayment($payment, $mollie_payment)
     {
         // Extract the payment method for transaction description
         $method = self::paymentMethod($mollie_payment, 'Mollie');
 
         // 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 Mollie payment/mandate details
      */
     protected static function paymentMethod($object, $default = ''): string
     {
         $details = $object->details;
 
         // Mollie supports 3 methods here
         switch ($object->method) {
-            case 'creditcard':
+            case self::METHOD_CREDITCARD:
                 // If the customer started, but never finished the 'first' payment
                 // card details will be empty, and mandate will be 'pending'.
                 if (empty($details->cardNumber)) {
                     return 'Credit Card';
                 }
 
                 return sprintf(
                     '%s (**** **** **** %s)',
                     $details->cardLabel ?: 'Card', // @phpstan-ignore-line
                     $details->cardNumber
                 );
 
-            case 'directdebit':
+            case self::METHOD_DIRECTDEBIT:
                 return sprintf('Direct Debit (%s)', $details->customerAccount);
 
-            case 'paypal':
+            case self::METHOD_PAYPAL:
                 return sprintf('PayPal (%s)', $details->consumerAccount);
         }
 
         return $default;
     }
+
+    /**
+     * List supported payment methods.
+     *
+     * @param string $type The payment type for which we require a method (oneoff/recurring).
+     *
+     * @return array Array of array with available payment methods:
+     *               - id: id of the method
+     *               - name: User readable name of the payment method
+     *               - minimumAmount: Minimum amount to be charged in cents
+     *               - currency: Currency used for the method
+     *               - exchangeRate: The projected exchange rate (actual rate is determined during payment)
+     *               - icon: An icon (icon name) representing the method
+     */
+    public function providerPaymentMethods($type): array
+    {
+
+        $providerMethods = array_merge(
+            // Fallback to EUR methods (later provider methods will override earlier ones)
+            //mollie()->methods()->allActive(
+            //    [
+            //        'sequenceType' => $type,
+            //        'amount' => [
+            //            'value' => '1.00',
+            //            'currency' => 'EUR'
+            //        ]
+            //    ]
+            //),
+            // Prefer CHF methods
+            (array)mollie()->methods()->allActive(
+                [
+                    'sequenceType' => $type,
+                    'amount' => [
+                        'value' => '1.00',
+                        'currency' => 'CHF'
+                    ]
+                ]
+            )
+        );
+
+        $availableMethods = [];
+        foreach ($providerMethods as $method) {
+            $availableMethods[$method->id] = [
+                'id' => $method->id,
+                'name' => $method->description,
+                'minimumAmount' => round(floatval($method->minimumAmount->value) * 100), // Converted to cents
+                'currency' => $method->minimumAmount->currency,
+                'exchangeRate' => $this->exchangeRate('CHF', $method->minimumAmount->currency)
+            ];
+        }
+
+        return $availableMethods;
+    }
+
+    /**
+     * Get a payment.
+     *
+     * @param string $paymentId Payment identifier
+     *
+     * @return array Payment information:
+     *                    - id: Payment identifier
+     *                    - status: Payment status
+     *                    - isCancelable: The payment can be canceled
+     *                    - checkoutUrl: The checkout url to complete the payment or null if none
+     */
+    public function getPayment($paymentId): array
+    {
+        $payment = mollie()->payments()->get($paymentId);
+
+        return [
+            'id' => $payment->id,
+            'status' => $payment->status,
+            'isCancelable' => $payment->isCancelable,
+            'checkoutUrl' => $payment->getCheckoutUrl()
+        ];
+    }
 }
diff --git a/src/app/Providers/Payment/Stripe.php b/src/app/Providers/Payment/Stripe.php
index 58fd8ba6..6c20642d 100644
--- a/src/app/Providers/Payment/Stripe.php
+++ b/src/app/Providers/Payment/Stripe.php
@@ -1,473 +1,558 @@
 <?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 (not used)
      *                             - 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' => Utils::serviceUrl('/wallet'), // required
             'success_url' => Utils::serviceUrl('/wallet'), // required
             'payment_method_types' => ['card'], // required
             'locale' => 'en',
             'mode' => 'setup',
         ];
 
         // Note: Stripe does not allow to set amount for 'setup' operation
         // We'll dispatch WalletCharge job when we receive a webhook request
 
         $session = StripeAPI\Checkout\Session::create($request);
 
         $payment['amount'] = 0;
+        $payment['currency_amount'] = 0;
         $payment['id'] = $session->setup_intent;
         $payment['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);
 
+
+        $amount = $this->exchange($payment['amount'], $wallet->currency, $payment['currency']);
+        $payment['currency_amount'] = $amount;
+
         $request = [
             'customer' => $customer_id,
             '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'],
+                    'amount' => $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;
         }
 
+        $amount = $this->exchange($payment['amount'], $wallet->currency, $payment['currency']);
+        $payment['currency_amount'] = $amount;
+
         $request = [
-            'amount' => $payment['amount'],
+            'amount' => $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) {
+            \Log::error("Invalid payload: " . $e->getMessage());
             // 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);
                     $threshold = intval((float) $payment->wallet->getSetting('mandate_balance') * 100);
 
                     // Top-up the wallet if balance is below the threshold
                     if ($payment->wallet->balance < $threshold && $payment->status != self::STATUS_PAID) {
                         \App\Jobs\WalletCharge::dispatch($payment->wallet);
                     }
                 }
 
                 $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;
     }
+
+    /**
+     * List supported payment methods.
+     *
+     * @param string $type The payment type for which we require a method (oneoff/recurring).
+     *
+     * @return array Array of array with available payment methods:
+     *               - id: id of the method
+     *               - name: User readable name of the payment method
+     *               - minimumAmount: Minimum amount to be charged in cents
+     *               - currency: Currency used for the method
+     *               - exchangeRate: The projected exchange rate (actual rate is determined during payment)
+     *               - icon: An icon (icon name) representing the method
+     */
+    public function providerPaymentMethods($type): array
+    {
+        //TODO get this from the stripe API?
+        $availableMethods = [];
+        switch ($type) {
+            case self::TYPE_ONEOFF:
+                $availableMethods = [
+                    self::METHOD_CREDITCARD => [
+                        'id' => self::METHOD_CREDITCARD,
+                        'name' => "Credit Card",
+                        'minimumAmount' => self::MIN_AMOUNT,
+                        'currency' => 'CHF',
+                        'exchangeRate' => 1.0
+                    ],
+                    self::METHOD_PAYPAL => [
+                        'id' => self::METHOD_PAYPAL,
+                        'name' => "PayPal",
+                        'minimumAmount' => self::MIN_AMOUNT,
+                        'currency' => 'CHF',
+                        'exchangeRate' => 1.0
+                    ]
+                ];
+                break;
+            case self::TYPE_RECURRING:
+                $availableMethods = [
+                    self::METHOD_CREDITCARD => [
+                        'id' => self::METHOD_CREDITCARD,
+                        'name' => "Credit Card",
+                        'minimumAmount' => self::MIN_AMOUNT, // Converted to cents,
+                        'currency' => 'CHF',
+                        'exchangeRate' => 1.0
+                    ]
+                ];
+                break;
+        }
+
+        return $availableMethods;
+    }
+
+    /**
+     * Get a payment.
+     *
+     * @param string $paymentId Payment identifier
+     *
+     * @return array Payment information:
+     *                    - id: Payment identifier
+     *                    - status: Payment status
+     *                    - isCancelable: The payment can be canceled
+     *                    - checkoutUrl: The checkout url to complete the payment or null if none
+     */
+    public function getPayment($paymentId): array
+    {
+        \Log::info("Stripe::getPayment does not yet retrieve a checkoutUrl.");
+
+        $payment = StripeAPI\PaymentIntent::retrieve($paymentId);
+        return [
+            'id' => $payment->id,
+            'status' => $payment->status,
+            'isCancelable' => false,
+            'checkoutUrl' => null
+        ];
+    }
 }
diff --git a/src/app/Providers/PaymentProvider.php b/src/app/Providers/PaymentProvider.php
index aa27ceca..30d41a8e 100644
--- a/src/app/Providers/PaymentProvider.php
+++ b/src/app/Providers/PaymentProvider.php
@@ -1,197 +1,388 @@
 <?php
 
 namespace App\Providers;
 
 use App\Transaction;
 use App\Payment;
 use App\Wallet;
+use Illuminate\Support\Facades\Cache;
 
 abstract class PaymentProvider
 {
     public const STATUS_OPEN = 'open';
     public const STATUS_CANCELED = 'canceled';
     public const STATUS_PENDING = 'pending';
     public const STATUS_AUTHORIZED = 'authorized';
     public const STATUS_EXPIRED = 'expired';
     public const STATUS_FAILED = 'failed';
     public const STATUS_PAID = 'paid';
 
     public const TYPE_ONEOFF = 'oneoff';
     public const TYPE_RECURRING = 'recurring';
     public const TYPE_MANDATE = 'mandate';
     public const TYPE_REFUND = 'refund';
     public const TYPE_CHARGEBACK = 'chargeback';
 
+    public const METHOD_CREDITCARD = 'creditcard';
+    public const METHOD_PAYPAL = 'paypal';
+    public const METHOD_BANKTRANSFER = 'banktransfer';
+    public const METHOD_DIRECTDEBIT = 'directdebit';
+
+    public const PROVIDER_MOLLIE = 'mollie';
+    public const PROVIDER_STRIPE = 'stripe';
+
     /** const int Minimum amount of money in a single payment (in cents) */
     public const MIN_AMOUNT = 1000;
 
+    private static $paymentMethodIcons = [
+        self::METHOD_CREDITCARD => ['prefix' => 'far', 'name' => 'credit-card'],
+        self::METHOD_PAYPAL => ['prefix' => 'fab', 'name' => 'paypal'],
+        self::METHOD_BANKTRANSFER => ['prefix' => 'fas', 'name' => 'university']
+    ];
+
     /**
-     * Factory method
+     * Detect the name of the provider
      *
      * @param \App\Wallet|string|null $provider_or_wallet
+     * @return string The name of the provider
      */
-    public static function factory($provider_or_wallet = null)
+    private static function providerName($provider_or_wallet = null): string
     {
         if ($provider_or_wallet instanceof Wallet) {
             if ($provider_or_wallet->getSetting('stripe_id')) {
-                $provider = 'stripe';
+                $provider = self::PROVIDER_STRIPE;
             } elseif ($provider_or_wallet->getSetting('mollie_id')) {
-                $provider = 'mollie';
+                $provider = self::PROVIDER_MOLLIE;
             }
         } else {
             $provider = $provider_or_wallet;
         }
 
         if (empty($provider)) {
-            $provider = \config('services.payment_provider') ?: 'mollie';
+            $provider = \config('services.payment_provider') ?: self::PROVIDER_MOLLIE;
         }
 
-        switch (\strtolower($provider)) {
-            case 'stripe':
+        return \strtolower($provider);
+    }
+
+    /**
+     * Factory method
+     *
+     * @param \App\Wallet|string|null $provider_or_wallet
+     */
+    public static function factory($provider_or_wallet = null)
+    {
+        switch (self::providerName($provider_or_wallet)) {
+            case self::PROVIDER_STRIPE:
                 return new \App\Providers\Payment\Stripe();
 
-            case 'mollie':
+            case self::PROVIDER_MOLLIE:
                 return new \App\Providers\Payment\Mollie();
 
             default:
-                throw new \Exception("Invalid payment provider: {$provider}");
+                throw new \Exception("Invalid payment provider: {$provider_or_wallet}");
         }
     }
 
     /**
      * 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.
+     *                             - methodId: Payment method
      *
      * @return array Provider payment data:
      *               - id: Operation identifier
      *               - redirectUrl: the location to redirect to
      */
     abstract public function createMandate(Wallet $wallet, array $payment): ?array;
 
     /**
      * Revoke the auto-payment mandate for a wallet.
      *
      * @param \App\Wallet $wallet The wallet
      *
      * @return bool True on success, False on failure
      */
     abstract public function deleteMandate(Wallet $wallet): bool;
 
     /**
      * 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.
+     *                    - methodId: Payment method
      *                    - isPending: the process didn't complete yet
      *                    - isValid: the mandate is valid
      */
     abstract public function getMandate(Wallet $wallet): ?array;
 
     /**
      * 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
      */
     abstract public function customerLink(Wallet $wallet): ?string;
 
     /**
      * Get a provider name
      *
      * @return string Provider name
      */
     abstract public function name(): string;
 
     /**
      * 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 description
+     *                             - methodId: Payment method
      *
      * @return array Provider payment/session data:
      *               - id: Operation identifier
      *               - redirectUrl
      */
     abstract public function payment(Wallet $wallet, array $payment): ?array;
 
     /**
      * Update payment status (and balance).
      *
      * @return int HTTP response code
      */
     abstract public function webhook(): int;
 
     /**
      * Create a payment record in DB
      *
      * @param array  $payment   Payment information
      * @param string $wallet_id Wallet ID
      *
      * @return \App\Payment Payment object
      */
     protected function storePayment(array $payment, $wallet_id): Payment
     {
         $db_payment = new Payment();
         $db_payment->id = $payment['id'];
         $db_payment->description = $payment['description'] ?? '';
         $db_payment->status = $payment['status'] ?? self::STATUS_OPEN;
         $db_payment->amount = $payment['amount'] ?? 0;
         $db_payment->type = $payment['type'];
         $db_payment->wallet_id = $wallet_id;
         $db_payment->provider = $this->name();
+        $db_payment->currency = $payment['currency'];
+        $db_payment->currency_amount = $payment['currency_amount'];
         $db_payment->save();
 
         return $db_payment;
     }
 
+    /**
+     * Retrieve an exchange rate.
+     *
+     * @param string $sourceCurrency Currency from which to convert
+     * @param string $targetCurrency Currency to convert to
+     *
+     * @return float Exchange rate
+     */
+    protected function exchangeRate(string $sourceCurrency, string $targetCurrency): float
+    {
+        if (strcasecmp($sourceCurrency, $targetCurrency)) {
+            throw new \Exception("Currency conversion is not yet implemented.");
+            //FIXME Not yet implemented
+        }
+        return 1.0;
+    }
+
+    /**
+     * Convert a value from $sourceCurrency to $targetCurrency
+     *
+     * @param int    $amount         Amount in cents of $sourceCurrency
+     * @param string $sourceCurrency Currency from which to convert
+     * @param string $targetCurrency Currency to convert to
+     *
+     * @return int Exchanged amount in cents of $targetCurrency
+     */
+    protected function exchange(int $amount, string $sourceCurrency, string $targetCurrency): int
+    {
+        return intval(round($amount * $this->exchangeRate($sourceCurrency, $targetCurrency)));
+    }
+
     /**
      * Deduct an amount of pecunia from the wallet.
      * Creates a payment and transaction records for the refund/chargeback operation.
      *
      * @param \App\Wallet $wallet A wallet object
      * @param array       $refund A refund or chargeback data (id, type, amount, description)
      *
      * @return void
      */
     protected function storeRefund(Wallet $wallet, array $refund): void
     {
         if (empty($refund) || empty($refund['amount'])) {
             return;
         }
 
-        $wallet->balance -= $refund['amount'];
+        // Preserve originally refunded amount
+        $refund['currency_amount'] = $refund['amount'];
+
+        // Convert amount to wallet currency
+        // TODO We should possibly be using the same exchange rate as for the original payment?
+        $amount = $this->exchange($refund['amount'], $refund['currency'], $wallet->currency);
+
+        $wallet->balance -= $amount;
         $wallet->save();
 
         if ($refund['type'] == self::TYPE_CHARGEBACK) {
             $transaction_type = Transaction::WALLET_CHARGEBACK;
         } else {
             $transaction_type = Transaction::WALLET_REFUND;
         }
 
         Transaction::create([
                 'object_id' => $wallet->id,
                 'object_type' => Wallet::class,
                 'type' => $transaction_type,
-                'amount' => $refund['amount'] * -1,
+                'amount' => $amount * -1,
                 'description' => $refund['description'] ?? '',
         ]);
 
         $refund['status'] = self::STATUS_PAID;
-        $refund['amount'] *= -1;
+        $refund['amount'] = -1 * $amount;
 
         $this->storePayment($refund, $wallet->id);
     }
+
+    /**
+     * List supported payment methods from this provider
+     *
+     * @param string $type The payment type for which we require a method (oneoff/recurring).
+     *
+     * @return array Array of array with available payment methods:
+     *               - id: id of the method
+     *               - name: User readable name of the payment method
+     *               - minimumAmount: Minimum amount to be charged in cents
+     *               - currency: Currency used for the method
+     *               - exchangeRate: The projected exchange rate (actual rate is determined during payment)
+     *               - icon: An icon (icon name) representing the method
+     */
+    abstract public function providerPaymentMethods($type): array;
+
+    /**
+     * Get a payment.
+     *
+     * @param string $paymentId Payment identifier
+     *
+     * @return array Payment information:
+     *                    - id: Payment identifier
+     *                    - status: Payment status
+     *                    - isCancelable: The payment can be canceled
+     *                    - checkoutUrl: The checkout url to complete the payment or null if none
+     */
+    abstract public function getPayment($paymentId): array;
+
+    /**
+     * Return an array of whitelisted payment methods with override values.
+     *
+     * @param string $type The payment type for which we require a method.
+     *
+     * @return array Array of methods
+     */
+    protected static function paymentMethodsWhitelist($type): array
+    {
+        switch ($type) {
+            case self::TYPE_ONEOFF:
+                return [
+                    self::METHOD_CREDITCARD => [
+                        'id' => self::METHOD_CREDITCARD,
+                        'icon' => self::$paymentMethodIcons[self::METHOD_CREDITCARD]
+                    ],
+                    self::METHOD_PAYPAL => [
+                        'id' => self::METHOD_PAYPAL,
+                        'icon' => self::$paymentMethodIcons[self::METHOD_PAYPAL]
+                    ],
+                    // TODO Enable once we're ready to offer them
+                    // self::METHOD_BANKTRANSFER => [
+                    //     'id' => self::METHOD_BANKTRANSFER,
+                    //     'icon' => self::$paymentMethodIcons[self::METHOD_BANKTRANSFER]
+                    // ]
+                ];
+            case PaymentProvider::TYPE_RECURRING:
+                return [
+                    self::METHOD_CREDITCARD => [
+                        'id' => self::METHOD_CREDITCARD,
+                        'icon' => self::$paymentMethodIcons[self::METHOD_CREDITCARD]
+                    ]
+                ];
+        }
+
+        \Log::error("Unknown payment type: " . $type);
+        return [];
+    }
+
+    /**
+     * Return an array of whitelisted payment methods with override values.
+     *
+     * @param string $type The payment type for which we require a method.
+     *
+     * @return array Array of methods
+     */
+    private static function applyMethodWhitelist($type, $availableMethods): array
+    {
+        $methods = [];
+
+        // Use only whitelisted methods, and apply values from whitelist (overriding the backend)
+        $whitelistMethods = self::paymentMethodsWhitelist($type);
+        foreach ($whitelistMethods as $id => $whitelistMethod) {
+            if (array_key_exists($id, $availableMethods)) {
+                $methods[] = array_merge($availableMethods[$id], $whitelistMethod);
+            }
+        }
+
+        return $methods;
+    }
+
+    /**
+     * List supported payment methods for $wallet
+     *
+     * @param \App\Wallet $wallet The wallet
+     * @param string      $type   The payment type for which we require a method (oneoff/recurring).
+     *
+     * @return array Array of array with available payment methods:
+     *               - id: id of the method
+     *               - name: User readable name of the payment method
+     *               - minimumAmount: Minimum amount to be charged in cents
+     *               - currency: Currency used for the method
+     *               - exchangeRate: The projected exchange rate (actual rate is determined during payment)
+     *               - icon: An icon (icon name) representing the method
+     */
+    public static function paymentMethods(Wallet $wallet, $type): array
+    {
+        $providerName = self::providerName($wallet);
+
+        $cacheKey = "methods-" . $providerName . '-' . $type;
+
+        if ($methods = Cache::get($cacheKey)) {
+            \Log::debug("Using payment method cache" . var_export($methods, true));
+            return $methods;
+        }
+
+        $provider = PaymentProvider::factory($providerName);
+        $methods = self::applyMethodWhitelist($type, $provider->providerPaymentMethods($type));
+
+        Cache::put($cacheKey, $methods, now()->addHours(1));
+
+        return $methods;
+    }
 }
diff --git a/src/database/migrations/2021_02_23_084157_payment_table_add_currency_columns.php b/src/database/migrations/2021_02_23_084157_payment_table_add_currency_columns.php
new file mode 100644
index 00000000..7e42e1f6
--- /dev/null
+++ b/src/database/migrations/2021_02_23_084157_payment_table_add_currency_columns.php
@@ -0,0 +1,55 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Support\Facades\DB;
+
+// phpcs:ignore
+class PaymentTableAddCurrencyColumns extends Migration
+{
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::table(
+            'payments',
+            function (Blueprint $table) {
+                $table->string('currency')->nullable();
+                $table->integer('currency_amount')->nullable();
+            }
+        );
+
+        DB::table('payments')->update([
+            'currency' => 'CHF',
+            'currency_amount' => DB::raw("`amount`")
+        ]);
+
+        Schema::table(
+            'payments',
+            function (Blueprint $table) {
+                $table->string('currency')->nullable(false)->change();
+                $table->integer('currency_amount')->nullable(false)->change();
+            }
+        );
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::table(
+            'payments',
+            function (Blueprint $table) {
+                $table->dropColumn('currency');
+                $table->dropColumn('currency_amount');
+            }
+        );
+    }
+}
diff --git a/src/resources/js/app.js b/src/resources/js/app.js
index 1caefa0b..f744f992 100644
--- a/src/resources/js/app.js
+++ b/src/resources/js/app.js
@@ -1,477 +1,477 @@
 /**
  * First we will load all of this project's JavaScript dependencies which
  * includes Vue and other libraries. It is a great starting point when
  * building robust, powerful web applications using Vue and Laravel.
  */
 
 require('./bootstrap')
 
 import AppComponent from '../vue/App'
 import MenuComponent from '../vue/Widgets/Menu'
 import SupportForm from '../vue/Widgets/SupportForm'
 import store from './store'
 
 const loader = '<div class="app-loader"><div class="spinner-border" role="status"><span class="sr-only">Loading</span></div></div>'
 
 let isLoading = 0
 
 // Lock the UI with the 'loading...' element
 const startLoading = () => {
     isLoading++
     let loading = $('#app > .app-loader').removeClass('fadeOut')
     if (!loading.length) {
         $('#app').append($(loader))
     }
 }
 
 // Hide "loading" overlay
 const stopLoading = () => {
     if (isLoading > 0) {
         $('#app > .app-loader').addClass('fadeOut')
         isLoading--;
     }
 }
 
 let loadingRoute
 
 // Note: This has to be before the app is created
 // Note: You cannot use app inside of the function
 window.router.beforeEach((to, from, next) => {
     // check if the route requires authentication and user is not logged in
     if (to.matched.some(route => route.meta.requiresAuth) && !store.state.isLoggedIn) {
         // remember the original request, to use after login
         store.state.afterLogin = to;
 
         // redirect to login page
         next({ name: 'login' })
 
         return
     }
 
     if (to.meta.loading) {
         startLoading()
         loadingRoute = to.name
     }
 
     next()
 })
 
 window.router.afterEach((to, from) => {
     if (to.name && loadingRoute === to.name) {
         stopLoading()
         loadingRoute = null
     }
 
     // When changing a page remove old:
     // - error page
     // - modal backdrop
     $('#error-page,.modal-backdrop.show').remove()
 })
 
 const app = new Vue({
     el: '#app',
     components: {
         AppComponent,
         MenuComponent,
     },
     store,
     router: window.router,
     data() {
         return {
             isAdmin: window.isAdmin,
             appName: window.config['app.name'],
             appUrl: window.config['app.url'],
             themeDir: '/themes/' + window.config['app.theme']
         }
     },
     methods: {
         // Clear (bootstrap) form validation state
         clearFormValidation(form) {
             $(form).find('.is-invalid').removeClass('is-invalid')
             $(form).find('.invalid-feedback').remove()
         },
         hasRoute(name) {
             return this.$router.resolve({ name: name }).resolved.matched.length > 0
         },
         hasSKU(name) {
             const authInfo = store.state.authInfo
             return authInfo.statusInfo.skus && authInfo.statusInfo.skus.indexOf(name) != -1
         },
         isController(wallet_id) {
             if (wallet_id && store.state.authInfo) {
                 let i
                 for (i = 0; i < store.state.authInfo.wallets.length; i++) {
                     if (wallet_id == store.state.authInfo.wallets[i].id) {
                         return true
                     }
                 }
                 for (i = 0; i < store.state.authInfo.accounts.length; i++) {
                     if (wallet_id == store.state.authInfo.accounts[i].id) {
                         return true
                     }
                 }
             }
 
             return false
         },
         // Set user state to "logged in"
         loginUser(response, dashboard, update) {
             if (!update) {
                 store.commit('logoutUser') // destroy old state data
                 store.commit('loginUser')
             }
 
             localStorage.setItem('token', response.access_token)
             axios.defaults.headers.common.Authorization = 'Bearer ' + response.access_token
 
             if (response.email) {
                 store.state.authInfo = response
             }
 
             if (dashboard !== false) {
                 this.$router.push(store.state.afterLogin || { name: 'dashboard' })
             }
 
             store.state.afterLogin = null
 
             // Refresh the token before it expires
             let timeout = response.expires_in || 0
 
             // We'll refresh 60 seconds before the token expires
             if (timeout > 60) {
                 timeout -= 60
             }
 
             // TODO: We probably should try a few times in case of an error
             // TODO: We probably should prevent axios from doing any requests
             //       while the token is being refreshed
 
             this.refreshTimeout = setTimeout(() => {
                 axios.post('/api/auth/refresh').then(response => {
                     this.loginUser(response.data, false, true)
                 })
             }, timeout * 1000)
         },
         // Set user state to "not logged in"
         logoutUser(redirect) {
             store.commit('logoutUser')
             localStorage.setItem('token', '')
             delete axios.defaults.headers.common.Authorization
 
             if (redirect !== false) {
                 this.$router.push({ name: 'login' })
             }
 
             clearTimeout(this.refreshTimeout)
         },
         logo(mode) {
             let src = this.appUrl + this.themeDir + '/images/logo_' + (mode || 'header') + '.png'
 
             return `<img src="${src}" alt="${this.appName}">`
         },
         // Display "loading" overlay inside of the specified element
-        addLoader(elem) {
-            $(elem).css({position: 'relative'}).append($(loader).addClass('small'))
+        addLoader(elem, small = true) {
+            $(elem).css({position: 'relative'}).append(small ? $(loader).addClass('small') : $(loader))
         },
         // Remove loader element added in addLoader()
         removeLoader(elem) {
             $(elem).find('.app-loader').remove()
         },
         startLoading,
         stopLoading,
         isLoading() {
             return isLoading > 0
         },
         errorPage(code, msg) {
             // Until https://github.com/vuejs/vue-router/issues/977 is implemented
             // we can't really use router to display error page as it has two side
             // effects: it changes the URL and adds the error page to browser history.
             // For now we'll be replacing current view with error page "manually".
             const map = {
                 400: "Bad request",
                 401: "Unauthorized",
                 403: "Access denied",
                 404: "Not found",
                 405: "Method not allowed",
                 500: "Internal server error"
             }
 
             if (!msg) msg = map[code] || "Unknown Error"
 
             const error_page = `<div id="error-page" class="error-page"><div class="code">${code}</div><div class="message">${msg}</div></div>`
 
             $('#error-page').remove()
             $('#app').append(error_page)
 
             app.updateBodyClass('error')
         },
         errorHandler(error) {
             this.stopLoading()
 
             if (!error.response) {
                 // TODO: probably network connection error
             } else if (error.response.status === 401) {
                 // Remember requested route to come back to it after log in
                 if (this.$route.meta.requiresAuth) {
                     store.state.afterLogin = this.$route
                     this.logoutUser()
                 } else {
                     this.logoutUser(false)
                 }
             } else {
                 this.errorPage(error.response.status, error.response.statusText)
             }
         },
         downloadFile(url) {
             // TODO: This might not be a best way for big files as the content
             //       will be stored (temporarily) in browser memory
             // TODO: This method does not show the download progress in the browser
             //       but it could be implemented in the UI, axios has 'progress' property
             axios.get(url, { responseType: 'blob' })
                 .then(response => {
                     const link = document.createElement('a')
                     const contentDisposition = response.headers['content-disposition']
                     let filename = 'unknown'
 
                     if (contentDisposition) {
                         const match = contentDisposition.match(/filename="(.+)"/);
                         if (match.length === 2) {
                             filename = match[1];
                         }
                     }
 
                     link.href = window.URL.createObjectURL(response.data)
                     link.download = filename
                     link.click()
                 })
         },
         price(price, currency) {
             return ((price || 0) / 100).toLocaleString('de-DE', { style: 'currency', currency: currency || 'CHF' })
         },
         priceLabel(cost, units = 1, discount) {
             let index = ''
 
             if (units < 0) {
                 units = 1
             }
 
             if (discount) {
                 cost = Math.floor(cost * ((100 - discount) / 100))
                 index = '\u00B9'
             }
 
             return this.price(cost * units) + '/month' + index
         },
         clickRecord(event) {
             if (!/^(a|button|svg|path)$/i.test(event.target.nodeName)) {
                 let link = $(event.target).closest('tr').find('a')[0]
                 if (link) {
                     link.click()
                 }
             }
         },
         domainStatusClass(domain) {
             if (domain.isDeleted) {
                 return 'text-muted'
             }
 
             if (domain.isSuspended) {
                 return 'text-warning'
             }
 
             if (!domain.isVerified || !domain.isLdapReady || !domain.isConfirmed) {
                 return 'text-danger'
             }
 
             return 'text-success'
         },
         domainStatusText(domain) {
             if (domain.isDeleted) {
                 return 'Deleted'
             }
 
             if (domain.isSuspended) {
                 return 'Suspended'
             }
 
             if (!domain.isVerified || !domain.isLdapReady || !domain.isConfirmed) {
                 return 'Not Ready'
             }
 
             return 'Active'
         },
         pageName(path) {
             let page = this.$route.path
 
             // check if it is a "menu page", find the page name
             // otherwise we'll use the real path as page name
             window.config.menu.every(item => {
                 if (item.location == page && item.page) {
                     page = item.page
                     return false
                 }
             })
 
             page = page.replace(/^\//, '')
 
             return page ? page : '404'
         },
         supportDialog(container) {
             let dialog = $('#support-dialog')
 
             // FIXME: Find a nicer way of doing this
             if (!dialog.length) {
                 let form = new Vue(SupportForm)
                 form.$mount($('<div>').appendTo(container)[0])
                 form.$root = this
                 form.$toast = this.$toast
                 dialog = $(form.$el)
             }
 
             dialog.on('shown.bs.modal', () => {
                     dialog.find('input').first().focus()
                 }).modal()
         },
         userStatusClass(user) {
             if (user.isDeleted) {
                 return 'text-muted'
             }
 
             if (user.isSuspended) {
                 return 'text-warning'
             }
 
             if (!user.isImapReady || !user.isLdapReady) {
                 return 'text-danger'
             }
 
             return 'text-success'
         },
         userStatusText(user) {
             if (user.isDeleted) {
                 return 'Deleted'
             }
 
             if (user.isSuspended) {
                 return 'Suspended'
             }
 
             if (!user.isImapReady || !user.isLdapReady) {
                 return 'Not Ready'
             }
 
             return 'Active'
         },
         updateBodyClass(name) {
             // Add 'class' attribute to the body, different for each page
             // so, we can apply page-specific styles
             let className = 'page-' + (name || this.pageName()).replace(/\/.*$/, '')
             $(document.body).removeClass().addClass(className)
         }
     }
 })
 
 // Add a axios request interceptor
 window.axios.interceptors.request.use(
     config => {
         // This is the only way I found to change configuration options
         // on a running application. We need this for browser testing.
         config.headers['X-Test-Payment-Provider'] = window.config.paymentProvider
 
         return config
     },
     error => {
         // Do something with request error
         return Promise.reject(error)
     }
 )
 
 // Add a axios response interceptor for general/validation error handler
 window.axios.interceptors.response.use(
     response => {
         if (response.config.onFinish) {
             response.config.onFinish()
         }
 
         return response
     },
     error => {
         let error_msg
         let status = error.response ? error.response.status : 200
 
         // Do not display the error in a toast message, pass the error as-is
         if (error.config.ignoreErrors) {
             return Promise.reject(error)
         }
 
         if (error.config.onFinish) {
             error.config.onFinish()
         }
 
         if (error.response && status == 422) {
             error_msg = "Form validation error"
 
             const modal = $('div.modal.show')
 
             $(modal.length ? modal : 'form').each((i, form) => {
                 form = $(form)
 
                 $.each(error.response.data.errors || {}, (idx, msg) => {
                     const input_name = (form.data('validation-prefix') || form.find('form').first().data('validation-prefix') || '') + idx
                     let input = form.find('#' + input_name)
 
                     if (!input.length) {
                         input = form.find('[name="' + input_name + '"]');
                     }
 
                     if (input.length) {
                         // Create an error message\
                         // API responses can use a string, array or object
                         let msg_text = ''
                         if ($.type(msg) !== 'string') {
                             $.each(msg, (index, str) => {
                                 msg_text += str + ' '
                             })
                         }
                         else {
                             msg_text = msg
                         }
 
                         let feedback = $('<div class="invalid-feedback">').text(msg_text)
 
                         if (input.is('.list-input')) {
                             // List input widget
                             input.children(':not(:first-child)').each((index, element) => {
                                 if (msg[index]) {
                                     $(element).find('input').addClass('is-invalid')
                                 }
                             })
 
                             input.addClass('is-invalid').next('.invalid-feedback').remove()
                             input.after(feedback)
                         }
                         else {
                             // Standard form element
                             input.addClass('is-invalid')
                             input.parent().find('.invalid-feedback').remove()
                             input.parent().append(feedback)
                         }
                     }
                 })
 
                 form.find('.is-invalid:not(.listinput-widget)').first().focus()
             })
         }
         else if (error.response && error.response.data) {
             error_msg = error.response.data.message
         }
         else {
             error_msg = error.request ? error.request.statusText : error.message
         }
 
         app.$toast.error(error_msg || "Server Error")
 
         // Pass the error as-is
         return Promise.reject(error)
     }
 )
diff --git a/src/resources/js/fontawesome.js b/src/resources/js/fontawesome.js
index aadaba73..93297fa2 100644
--- a/src/resources/js/fontawesome.js
+++ b/src/resources/js/fontawesome.js
@@ -1,59 +1,66 @@
 
 import { library } from '@fortawesome/fontawesome-svg-core'
 import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'
 //import { } from '@fortawesome/free-brands-svg-icons'
 import {
     faCheckSquare,
     faCreditCard,
     faSquare,
 } from '@fortawesome/free-regular-svg-icons'
 
 import {
     faCheck,
     faCheckCircle,
     faComments,
     faDownload,
     faEnvelope,
     faGlobe,
+    faUniversity,
     faExclamationCircle,
     faInfoCircle,
     faLock,
     faKey,
     faPlus,
     faSearch,
     faSignInAlt,
     faSyncAlt,
     faTrashAlt,
     faUser,
     faUserCog,
     faUsers,
     faWallet
 } from '@fortawesome/free-solid-svg-icons'
 
+import {
+    faPaypal
+} from '@fortawesome/free-brands-svg-icons'
+
 // Register only these icons we need
 library.add(
     faCheck,
     faCheckCircle,
     faCheckSquare,
     faComments,
     faCreditCard,
+    faPaypal,
+    faUniversity,
     faDownload,
     faEnvelope,
     faExclamationCircle,
     faGlobe,
     faInfoCircle,
     faLock,
     faKey,
     faPlus,
     faSearch,
     faSignInAlt,
     faSquare,
     faSyncAlt,
     faTrashAlt,
     faUser,
     faUserCog,
     faUsers,
     faWallet
 )
 
 export default FontAwesomeIcon
diff --git a/src/resources/themes/app.scss b/src/resources/themes/app.scss
index b3944964..c5b8c840 100644
--- a/src/resources/themes/app.scss
+++ b/src/resources/themes/app.scss
@@ -1,431 +1,452 @@
 html,
 body,
 body > .outer-container {
     height: 100%;
 }
 
 #app {
     display: flex;
     flex-direction: column;
     min-height: 100%;
     overflow: hidden;
 
     & > nav {
         flex-shrink: 0;
         z-index: 12;
     }
 
     & > div.container {
         flex-grow: 1;
         margin-top: 2rem;
         margin-bottom: 2rem;
     }
 
     & > .filler {
         flex-grow: 1;
     }
 
     & > div.container + .filler {
         display: none;
     }
 }
 
 .error-page {
     position: absolute;
     top: 0;
     height: 100%;
     width: 100%;
     align-items: center;
     display: flex;
     justify-content: center;
     color: #636b6f;
     z-index: 10;
     background: white;
 
     .code {
         text-align: right;
         border-right: 2px solid;
         font-size: 26px;
         padding: 0 15px;
     }
 
     .message {
         font-size: 18px;
         padding: 0 15px;
     }
 }
 
 .app-loader {
     background-color: $body-bg;
     height: 100%;
     width: 100%;
     position: absolute;
     top: 0;
     left: 0;
     display: flex;
     align-items: center;
     justify-content: center;
     z-index: 8;
 
     .spinner-border {
         width: 120px;
         height: 120px;
         border-width: 15px;
         color: #b2aa99;
     }
 
     &.small .spinner-border {
         width: 25px;
         height: 25px;
         border-width: 3px;
     }
 
     &.fadeOut {
         visibility: hidden;
         opacity: 0;
         transition: visibility 300ms linear, opacity 300ms linear;
     }
 }
 
 pre {
     margin: 1rem 0;
     padding: 1rem;
     background-color: $menu-bg-color;
 }
 
 .card-title {
     font-size: 1.2rem;
     font-weight: bold;
 }
 
 tfoot.table-fake-body {
     background-color: #f8f8f8;
     color: grey;
     text-align: center;
 
     td {
         vertical-align: middle;
         height: 8em;
         border: 0;
     }
 
     tbody:not(:empty) + & {
         display: none;
     }
 }
 
 table {
     td.buttons,
     td.email,
     td.price,
     td.datetime,
     td.selection {
         width: 1%;
         white-space: nowrap;
     }
 
     th.price,
     td.price {
         width: 1%;
         text-align: right;
         white-space: nowrap;
     }
 
     &.form-list {
         margin: 0;
 
         td {
             border: 0;
 
             &:first-child {
                 padding-left: 0;
             }
 
             &:last-child {
                 padding-right: 0;
             }
         }
 
         button {
             line-height: 1;
         }
     }
 
     .btn-action {
         line-height: 1;
         padding: 0;
     }
 }
 
 .list-details {
     min-height: 1em;
 
     & > ul {
         margin: 0;
         padding-left: 1.2em;
     }
 }
 
 .plan-selector {
     .plan-header {
         display: flex;
     }
 
     .plan-ico {
         margin:auto;
         font-size: 3.8rem;
         color: #f1a539;
         border: 3px solid #f1a539;
         width: 6rem;
         height: 6rem;
         border-radius: 50%;
     }
 }
 
 .status-message {
     display: flex;
     align-items: center;
     justify-content: center;
 
     .app-loader {
         width: auto;
         position: initial;
 
         .spinner-border {
             color: $body-color;
         }
     }
 
     svg {
         font-size: 1.5em;
     }
 
     :first-child {
         margin-right: 0.4em;
     }
 }
 
 .form-separator {
     position: relative;
     margin: 1em 0;
     display: flex;
     justify-content: center;
 
     hr {
         border-color: #999;
         margin: 0;
         position: absolute;
         top: 0.75em;
         width: 100%;
     }
 
     span {
         background: #fff;
         padding: 0 1em;
         z-index: 1;
     }
 }
 
 #status-box {
     background-color: lighten($green, 35);
 
     .progress {
         background-color: #fff;
         height: 10px;
     }
 
     .progress-label {
         font-size: 0.9em;
     }
 
     .progress-bar {
         background-color: $green;
     }
 
     &.process-failed {
         background-color: lighten($orange, 30);
 
         .progress-bar {
             background-color: $red;
         }
     }
 }
 
 @keyframes blinker {
     50% {
         opacity: 0;
     }
 }
 
 .blinker {
     animation: blinker 750ms step-start infinite;
 }
 
 #dashboard-nav {
     display: flex;
     flex-wrap: wrap;
     justify-content: center;
 
     & > a {
         padding: 1rem;
         text-align: center;
         white-space: nowrap;
         margin: 0.25rem;
         text-decoration: none;
         width: 150px;
 
         &.disabled {
             pointer-events: none;
             opacity: 0.6;
         }
 
         .badge {
             position: absolute;
             top: 0.5rem;
             right: 0.5rem;
         }
     }
 
     svg {
         width: 6rem;
         height: 6rem;
         margin: auto;
     }
 }
 
+#payment-method-selection {
+    display: flex;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    & > a {
+        padding: 1rem;
+        text-align: center;
+        white-space: nowrap;
+        margin: 0.25rem;
+        text-decoration: none;
+        width: 150px;
+    }
+
+    svg {
+        width: 6rem;
+        height: 6rem;
+        margin: auto;
+    }
+}
+
 #logon-form {
     flex-basis: auto; // Bootstrap issue? See logon page with width < 992
 }
 
 #logon-form-footer {
     a:not(:first-child) {
         margin-left: 2em;
     }
 }
 
 // Various improvements for mobile
 @include media-breakpoint-down(sm) {
     .card,
     .card-footer {
         border: 0;
     }
 
     .card-body {
         padding: 0.5rem 0;
     }
 
     .form-group {
         margin-bottom: 0.5rem;
     }
 
     .nav-tabs {
         flex-wrap: nowrap;
         overflow-x: auto;
 
         .nav-link {
             white-space: nowrap;
             padding: 0.5rem 0.75rem;
         }
     }
 
     .tab-content {
         margin-top: 0.5rem;
     }
 
     .col-form-label {
         color: #666;
         font-size: 95%;
     }
 
     .form-group.plaintext .col-form-label {
         padding-bottom: 0;
     }
 
     form.read-only.short label {
         width: 35%;
 
         & + * {
             width: 65%;
         }
     }
 
     #app > div.container {
         margin-bottom: 1rem;
         margin-top: 1rem;
         max-width: 100%;
     }
 
     #header-menu-navbar {
         padding: 0;
     }
 
     #dashboard-nav > a {
         width: 135px;
     }
 
     .table-sm:not(.form-list) {
         tbody td {
             padding: 0.75rem 0.5rem;
 
             svg {
                 vertical-align: -0.175em;
             }
 
             & > svg {
                 font-size: 125%;
                 margin-right: 0.25rem;
             }
         }
     }
 
     .table.transactions {
         thead {
             display: none;
         }
 
         tbody {
             tr {
                 position: relative;
                 display: flex;
                 flex-wrap: wrap;
             }
 
             td {
                 width: auto;
                 border: 0;
                 padding: 0.5rem;
 
                 &.datetime {
                     width: 50%;
                     padding-left: 0;
                 }
 
                 &.description {
                     order: 3;
                     width: 100%;
                     border-bottom: 1px solid $border-color;
                     color: $secondary;
                     padding: 0 1.5em 0.5rem 0;
                     margin-top: -0.25em;
                 }
 
                 &.selection {
                     position: absolute;
                     right: 0;
                     border: 0;
                     top: 1.7em;
                     padding-right: 0;
                 }
 
                 &.price {
                     width: 50%;
                     padding-right: 0;
                 }
 
                 &.email {
                     display: none;
                 }
             }
         }
     }
 }
diff --git a/src/resources/vue/Wallet.vue b/src/resources/vue/Wallet.vue
index ed31fe1d..fc71405c 100644
--- a/src/resources/vue/Wallet.vue
+++ b/src/resources/vue/Wallet.vue
@@ -1,372 +1,473 @@
 <template>
     <div class="container" dusk="wallet-component">
         <div v-if="wallet.id" id="wallet" class="card">
             <div class="card-body">
                 <div class="card-title">Account balance <span :class="wallet.balance < 0 ? 'text-danger' : 'text-success'">{{ $root.price(wallet.balance, wallet.currency) }}</span></div>
                 <div class="card-text">
                     <p v-if="wallet.notice" id="wallet-notice">{{ wallet.notice }}</p>
-                    <p>Add credit to your account or setup an automatic payment by using the button below.</p>
-                    <button type="button" class="btn btn-primary" @click="paymentDialog()">Add credit</button>
+
+                    <div v-if="showPendingPayments" class="alert alert-warning">
+                        You have payments that are still in progress. See the "Pending Payments" tab below.
+                    </div>
+                    <p>
+                        <button type="button" class="btn btn-primary" @click="paymentMethodForm('manual')">Add credit</button>
+                    </p>
+                    <div id="mandate-form" v-if="!mandate.isValid && !mandate.isPending">
+                        <template v-if="mandate.id && !mandate.isValid">
+                            <div class="alert alert-danger">
+                                The setup of automatic payments failed. Restart the process to enable automatic top-ups.
+                            </div>
+                            <button type="button" class="btn btn-danger" @click="autoPaymentDelete">Cancel auto-payment</button>
+                        </template>
+                        <button type="button" class="btn btn-primary" @click="paymentMethodForm('auto')">Set up auto-payment</button>
+                    </div>
+                    <div id="mandate-info" v-else>
+                        <div v-if="mandate.isDisabled" class="disabled-mandate alert alert-danger">
+                            The configured auto-payment has been disabled. Top up your wallet or
+                            raise the auto-payment amount.
+                        </div>
+                        <template v-else>
+                            <p>
+                                Auto-payment is <b>set</b> to fill up your account by <b>{{ mandate.amount }} CHF</b>
+                                every time your account balance gets under <b>{{ mandate.balance }} CHF</b>.
+                            </p>
+                            <p>
+                                Method of payment: {{ mandate.method }}
+                            </p>
+                        </template>
+                        <div v-if="mandate.isPending" class="alert alert-warning">
+                            The setup of the automatic payment is still in progress.
+                        </div>
+                        <p>
+                            <button type="button" class="btn btn-danger" @click="autoPaymentDelete">Cancel auto-payment</button>
+                            <button type="button" class="btn btn-primary" @click="autoPaymentChange">Change auto-payment</button>
+                        </p>
+                    </div>
                 </div>
             </div>
         </div>
 
         <ul class="nav nav-tabs mt-3" role="tablist">
             <li class="nav-item">
                 <a class="nav-link active" id="tab-receipts" href="#wallet-receipts" role="tab" aria-controls="wallet-receipts" aria-selected="true">
                     Receipts
                 </a>
             </li>
             <li class="nav-item">
                 <a class="nav-link" id="tab-history" href="#wallet-history" role="tab" aria-controls="wallet-history" aria-selected="false">
                     History
                 </a>
             </li>
+            <li v-if="showPendingPayments" class="nav-item">
+                <a class="nav-link" id="tab-payments" href="#wallet-payments" role="tab" aria-controls="wallet-payments" aria-selected="false">
+                    Pending Payments
+                </a>
+            </li>
         </ul>
         <div class="tab-content">
-            <div class="tab-pane show active" id="wallet-receipts" role="tabpanel" aria-labelledby="tab-receipts">
+            <div class="tab-pane active" id="wallet-receipts" role="tabpanel" aria-labelledby="tab-receipts">
                 <div class="card-body">
                     <div class="card-text">
                         <p v-if="receipts.length">
                             Here you can download receipts (in PDF format) for payments in specified period.
                             Select the period and press the Download button.
                         </p>
                         <div v-if="receipts.length" class="input-group">
                             <select id="receipt-id" class="form-control">
                                 <option v-for="(receipt, index) in receipts" :key="index" :value="receipt">{{ receipt }}</option>
                             </select>
                             <div class="input-group-append">
                                 <button type="button" class="btn btn-secondary" @click="receiptDownload">
                                     <svg-icon icon="download"></svg-icon> Download
                                 </button>
                             </div>
                         </div>
                         <p v-if="!receipts.length">
                             There are no receipts for payments in this account. Please, note that you can download
                             receipts after the month ends.
                         </p>
                     </div>
                 </div>
             </div>
-            <div class="tab-pane show" id="wallet-history" role="tabpanel" aria-labelledby="tab-history">
+            <div class="tab-pane" id="wallet-history" role="tabpanel" aria-labelledby="tab-history">
                 <div class="card-body">
                     <transaction-log v-if="walletId && loadTransactions" class="card-text" :wallet-id="walletId"></transaction-log>
                 </div>
             </div>
+            <div class="tab-pane" id="wallet-payments" role="tabpanel" aria-labelledby="tab-payments">
+                <div class="card-body">
+                    <payment-log v-if="walletId && loadPayments" class="card-text" :wallet-id="walletId"></payment-log>
+                </div>
+            </div>
         </div>
 
         <div id="payment-dialog" class="modal" tabindex="-1" role="dialog">
             <div class="modal-dialog" role="document">
                 <div class="modal-content">
                     <div class="modal-header">
                         <h5 class="modal-title">{{ paymentDialogTitle }}</h5>
                         <button type="button" class="close" data-dismiss="modal" aria-label="Close">
                             <span aria-hidden="true">&times;</span>
                         </button>
                     </div>
                     <div class="modal-body">
-                        <div id="payment" v-if="paymentForm == 'init'">
+                        <div id="payment-method" v-if="paymentForm == 'method'">
+                            <form data-validation-prefix="mandate_">
+                                <div id="payment-method-selection">
+                                    <a :id="method.id" v-for="method in paymentMethods" :key="method.id" @click="selectPaymentMethod(method)" href="#" class="card link-profile">
+                                        <svg-icon v-if="method.icon" :icon="[method.icon.prefix, method.icon.name]" />
+                                        <img v-if="method.image" v-bind:src="method.image" />
+                                        <span class="name">{{ method.name }}</span>
+                                    </a>
+                                </div>
+                            </form>
+                        </div>
+                        <div id="manual-payment" v-if="paymentForm == 'manual'">
+                            <p v-if="wallet.currency != selectedPaymentMethod.currency">
+                                Here is how it works: You specify the amount by which you want to to up your wallet in {{ wallet.currency }}.
+                                We will then convert this to {{ selectedPaymentMethod.currency }}, and on the next page you will be provided with the bank-details
+                                to transfer the amount in {{ selectedPaymentMethod.currency }}.
+                            </p>
+                            <p v-if="selectedPaymentMethod.id == 'banktransfer'">
+                                Please note that a bank transfer can take several days to complete.
+                            </p>
                             <p>Choose the amount by which you want to top up your wallet.</p>
                             <form id="payment-form" @submit.prevent="payment">
                                 <div class="form-group">
                                     <div class="input-group">
                                         <input type="text" class="form-control" id="amount" v-model="amount" required>
                                         <span class="input-group-append">
                                             <span class="input-group-text">{{ wallet.currency }}</span>
                                         </span>
                                     </div>
                                 </div>
-                                <div class="w-100 text-center">
-                                    <button type="submit" class="btn btn-primary">
-                                        <svg-icon :icon="['far', 'credit-card']"></svg-icon> Continue
-                                    </button>
+                                <div v-if="wallet.currency != selectedPaymentMethod.currency && !isNaN(amount)" class="alert alert-warning">
+                                    You will be charged for {{ $root.price(amount * selectedPaymentMethod.exchangeRate * 100, selectedPaymentMethod.currency) }}
                                 </div>
                             </form>
-                            <div class="form-separator"><hr><span>or</span></div>
-                            <div id="mandate-form" v-if="!mandate.isValid && !mandate.isPending">
-                                <p>Add auto-payment, so you never run out.</p>
-                                <div v-if="mandate.id && !mandate.isValid" class="alert alert-danger">
-                                    The setup of automatic payments failed. Restart the process to enable automatic top-ups.
-                                </div>
-                                <div class="w-100 text-center">
-                                    <button type="button" class="btn btn-primary" @click="autoPaymentForm">Set up auto-payment</button>
-                                </div>
-                            </div>
-                            <div id="mandate-info" v-else>
-                                <p>
-                                    Auto-payment is set to fill up your account by <b>{{ mandate.amount }} CHF</b>
-                                    every time your account balance gets under <b>{{ mandate.balance }} CHF</b>.
-                                    You will be charged via {{ mandate.method }}.
-                                </p>
-                                <div v-if="mandate.isPending" class="alert alert-warning">
-                                    The setup of the automatic payment is still in progress.
-                                </div>
-                                <div v-else-if="mandate.isDisabled" class="disabled-mandate alert alert-danger">
-                                    The configured auto-payment has been disabled. Top up your wallet or
-                                    raise the auto-payment amount.
-                                </div>
-                                <p>You can cancel or change the auto-payment at any time.</p>
-                                <div class="form-group d-flex justify-content-around">
-                                    <button type="button" class="btn btn-danger" @click="autoPaymentDelete">Cancel auto-payment</button>
-                                    <button type="button" class="btn btn-primary" @click="autoPaymentChange">Change auto-payment</button>
-                                </div>
-                            </div>
                         </div>
                         <div id="auto-payment" v-if="paymentForm == 'auto'">
                             <form data-validation-prefix="mandate_">
                                 <p>
                                     Here is how it works: Every time your account runs low,
                                     we will charge your preferred payment method for an amount you choose.
                                     You can cancel or change the auto-payment option at any time.
                                 </p>
                                 <div class="form-group row">
                                     <label for="mandate_amount" class="col-sm-6 col-form-label">Fill up by</label>
                                     <div class="input-group col-sm-6">
                                         <input type="text" class="form-control" id="mandate_amount" v-model="mandate.amount" required>
                                         <span class="input-group-append">
                                             <span class="input-group-text">{{ wallet.currency }}</span>
                                         </span>
                                     </div>
                                 </div>
                                 <div class="form-group row">
                                     <label for="mandate_balance" class="col-sm-6 col-form-label">when account balance is below</label>
                                     <div class="col-sm-6">
                                         <div class="input-group">
                                             <input type="text" class="form-control" id="mandate_balance" v-model="mandate.balance" required>
                                             <span class="input-group-append">
                                                 <span class="input-group-text">{{ wallet.currency }}</span>
                                             </span>
                                         </div>
                                     </div>
                                 </div>
                                 <p v-if="!mandate.isValid">
                                     Next, you will be redirected to the checkout page, where you can provide
                                     your credit card details.
                                 </p>
                                 <div v-if="mandate.isValid && mandate.isDisabled" class="disabled-mandate alert alert-danger">
                                     The auto-payment is disabled. Immediately after you submit new settings we'll
                                     enable it and attempt to top up your wallet.
                                 </div>
                             </form>
                         </div>
                     </div>
                     <div class="modal-footer">
                         <button type="button" class="btn btn-secondary modal-cancel" data-dismiss="modal">Cancel</button>
                         <button type="button" class="btn btn-primary modal-action"
                                 v-if="paymentForm == 'auto' && (mandate.isValid || mandate.isPending)"
                                 @click="autoPayment"
                         >
                             <svg-icon icon="check"></svg-icon> Submit
                         </button>
                         <button type="button" class="btn btn-primary modal-action"
                                 v-if="paymentForm == 'auto' && !mandate.isValid && !mandate.isPending"
                                 @click="autoPayment"
                         >
-                            <svg-icon :icon="['far', 'credit-card']"></svg-icon> Continue
+                            <svg-icon icon="check"></svg-icon> Continue
+                        </button>
+                        <button type="button" class="btn btn-primary modal-action"
+                                v-if="paymentForm == 'manual'"
+                                @click="payment"
+                        >
+                            <svg-icon icon="check"></svg-icon> Continue
                         </button>
                     </div>
                 </div>
             </div>
         </div>
     </div>
 </template>
 
 <script>
     import TransactionLog from './Widgets/TransactionLog'
+    import PaymentLog from './Widgets/PaymentLog'
 
     export default {
         components: {
-            TransactionLog
+            TransactionLog,
+            PaymentLog
         },
         data() {
             return {
                 amount: '',
-                mandate: { amount: 10, balance: 0 },
+                mandate: { amount: 10, balance: 0, method: null },
                 paymentDialogTitle: null,
-                paymentForm: 'init',
+                paymentForm: null,
+                nextForm: null,
                 receipts: [],
                 stripe: null,
                 loadTransactions: false,
+                loadPayments: false,
+                showPendingPayments: false,
                 wallet: {},
-                walletId: null
+                walletId: null,
+                paymentMethods: [],
+                selectedPaymentMethod: null
             }
         },
         mounted() {
             $('#wallet button').focus()
 
             this.walletId = this.$store.state.authInfo.wallets[0].id
 
             this.$root.startLoading()
             axios.get('/api/v4/wallets/' + this.walletId)
                 .then(response => {
                     this.$root.stopLoading()
                     this.wallet = response.data
 
                     const receiptsTab = $('#wallet-receipts')
 
                     this.$root.addLoader(receiptsTab)
                     axios.get('/api/v4/wallets/' + this.walletId + '/receipts')
                         .then(response => {
                             this.$root.removeLoader(receiptsTab)
                             this.receipts = response.data.list
                         })
                         .catch(error => {
                             this.$root.removeLoader(receiptsTab)
                         })
 
                     if (this.wallet.provider == 'stripe') {
                         this.stripeInit()
                     }
                 })
                 .catch(this.$root.errorHandler)
 
+            this.loadMandate()
+
+            axios.get('/api/v4/payments/has-pending')
+                .then(response => {
+                    this.showPendingPayments = response.data.hasPending
+                })
+
+        },
+        updated() {
             $(this.$el).find('ul.nav-tabs a').on('click', e => {
                 e.preventDefault()
                 $(e.target).tab('show')
                 if ($(e.target).is('#tab-history')) {
                     this.loadTransactions = true
                 }
+                if ($(e.target).is('#tab-payments')) {
+                    this.loadPayments = true
+                }
             })
         },
         methods: {
-            paymentDialog() {
-                const dialog = $('#payment-dialog')
+            loadMandate() {
                 const mandate_form = $('#mandate-form')
 
                 this.$root.removeLoader(mandate_form)
 
                 if (!this.mandate.id || this.mandate.isPending) {
                     this.$root.addLoader(mandate_form)
                     axios.get('/api/v4/payments/mandate')
                         .then(response => {
                             this.$root.removeLoader(mandate_form)
                             this.mandate = response.data
                         })
                         .catch(error => {
                             this.$root.removeLoader(mandate_form)
                         })
                 }
+            },
+            selectPaymentMethod(method) {
+                this.formLock = false
+
+                this.selectedPaymentMethod = method
 
+                this.paymentForm = this.nextForm
                 this.formLock = false
-                this.paymentForm = 'init'
-                this.paymentDialogTitle = 'Top up your wallet'
 
-                this.dialog = dialog.on('shown.bs.modal', () => {
-                        dialog.find('#amount').focus()
-                    }).modal()
+                setTimeout(() => {
+                    this.dialog.find('#mandate_amount').focus()
+                    this.dialog.find('#amount').focus()
+                }, 10)
             },
             payment() {
                 if (this.formLock) {
                     return
                 }
 
                 // Lock the form to prevent from double submission
                 this.formLock = true
                 let onFinish = () => { this.formLock = false }
 
                 this.$root.clearFormValidation($('#payment-form'))
 
-                axios.post('/api/v4/payments', {amount: this.amount}, { onFinish })
+                axios.post('/api/v4/payments', {amount: this.amount, methodId: this.selectedPaymentMethod.id, currency: this.selectedPaymentMethod.currency}, { onFinish })
                     .then(response => {
                         if (response.data.redirectUrl) {
                             location.href = response.data.redirectUrl
                         } else {
                             this.stripeCheckout(response.data)
                         }
                     })
             },
             autoPayment() {
                 if (this.formLock) {
                     return
                 }
 
                 // Lock the form to prevent from double submission
                 this.formLock = true
                 let onFinish = () => { this.formLock = false }
 
                 const method = this.mandate.id && (this.mandate.isValid || this.mandate.isPending) ? 'put' : 'post'
-                const post = {
+                let post = {
                     amount: this.mandate.amount,
-                    balance: this.mandate.balance
+                    balance: this.mandate.balance,
+                }
+
+                // Modifications can't change the method of payment
+                if (this.selectedPaymentMethod) {
+                    post['methodId'] = this.selectedPaymentMethod.id;
+                    post['currency'] = this.selectedPaymentMethod.currency;
                 }
 
                 this.$root.clearFormValidation($('#auto-payment form'))
 
                 axios[method]('/api/v4/payments/mandate', post, { onFinish })
                     .then(response => {
                         if (method == 'post') {
                             this.mandate.id = null
                             // a new mandate, redirect to the chackout page
                             if (response.data.redirectUrl) {
                                 location.href = response.data.redirectUrl
                             } else if (response.data.id) {
                                 this.stripeCheckout(response.data)
                             }
                         } else {
                             // an update
                             if (response.data.status == 'success') {
                                 this.dialog.modal('hide');
                                 this.mandate = response.data
                                 this.$toast.success(response.data.message)
                             }
                         }
                     })
             },
             autoPaymentChange(event) {
                 this.autoPaymentForm(event, 'Update auto-payment')
             },
             autoPaymentDelete() {
                 axios.delete('/api/v4/payments/mandate')
                     .then(response => {
                         this.mandate = { amount: 10, balance: 0 }
                         if (response.data.status == 'success') {
                             this.$toast.success(response.data.message)
                         }
                     })
             },
+
+            paymentMethodForm(nextForm) {
+                const dialog = $('#payment-dialog')
+                this.formLock = false
+                this.paymentMethods = []
+
+                this.paymentForm = 'method'
+                this.nextForm = nextForm
+                if (nextForm == 'auto') {
+                    this.paymentDialogTitle = 'Add auto-payment'
+                } else {
+                    this.paymentDialogTitle = 'Top up your wallet'
+                }
+
+                const methods = $('#payment-method')
+                this.$root.addLoader(methods, false)
+                axios.get('/api/v4/payments/methods', {params: {type: nextForm == 'manual' ? 'oneoff' : 'recurring'}})
+                    .then(response => {
+                        this.$root.removeLoader(methods)
+                        this.paymentMethods = response.data
+                    })
+                    .catch(this.$root.errorHandler)
+
+                this.dialog = dialog.on('shown.bs.modal', () => {}).modal()
+            },
             autoPaymentForm(event, title) {
+                const dialog = $('#payment-dialog')
+
                 this.paymentForm = 'auto'
-                this.paymentDialogTitle = title || 'Add auto-payment'
+                this.paymentDialogTitle = title
                 this.formLock = false
+
+                this.dialog = dialog.on('shown.bs.modal', () => {
+                    dialog.find('#mandate_amount').focus()
+                }).modal()
+
                 setTimeout(() => { this.dialog.find('#mandate_amount').focus()}, 10)
             },
             receiptDownload() {
                 const receipt = $('#receipt-id').val()
                 this.$root.downloadFile('/api/v4/wallets/' + this.walletId + '/receipts/' + receipt)
             },
             stripeInit() {
                 let script = $('#stripe-script')
 
                 if (!script.length) {
                     script = document.createElement('script')
 
                     script.onload = () => {
                         this.stripe = Stripe(window.config.stripePK)
                     }
 
                     script.id = 'stripe-script'
                     script.src = 'https://js.stripe.com/v3/'
 
                     document.getElementsByTagName('head')[0].appendChild(script)
                 } else {
                     this.stripe = Stripe(window.config.stripePK)
                 }
             },
             stripeCheckout(data) {
                 if (!this.stripe) {
                     return
                 }
 
                 this.stripe.redirectToCheckout({
                     sessionId: data.id
                 }).then(result => {
                     // If it fails due to a browser or network error,
                     // display the localized error message to the user
                     if (result.error) {
                         this.$toast.error(result.error.message)
                     }
                 })
             }
         }
     }
 </script>
diff --git a/src/resources/vue/Widgets/PaymentLog.vue b/src/resources/vue/Widgets/PaymentLog.vue
new file mode 100644
index 00000000..4402db39
--- /dev/null
+++ b/src/resources/vue/Widgets/PaymentLog.vue
@@ -0,0 +1,76 @@
+<template>
+    <div>
+        <table class="table table-sm m-0 payments">
+            <thead class="thead-light">
+                <tr>
+                    <th scope="col">Date</th>
+                    <th scope="col">Description</th>
+                    <th scope="col"></th>
+                    <th scope="col" class="price">Amount</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr v-for="payment in payments" :id="'log' + payment.id" :key="payment.id">
+                    <td class="datetime">{{ payment.createdAt }}</td>
+                    <td class="description">{{ payment.description }}</td>
+                    <td><a v-if="payment.checkoutUrl" v-bind:href="payment.checkoutUrl">Details</a></td>
+                    <td class="price text-success">{{ amount(payment) }}</td>
+                </tr>
+            </tbody>
+            <tfoot class="table-fake-body">
+                <tr>
+                    <td colspan="4">There are no pending payments for this account.</td>
+                </tr>
+            </tfoot>
+        </table>
+        <div class="text-center p-3" id="payments-loader" v-if="hasMore">
+            <button class="btn btn-secondary" @click="loadLog(true)">Load more</button>
+        </div>
+    </div>
+</template>
+
+<script>
+    export default {
+        props: {
+        },
+        data() {
+            return {
+                payments: [],
+                hasMore: false,
+                page: 1
+            }
+        },
+        mounted() {
+            this.loadLog()
+        },
+        methods: {
+            loadLog(more) {
+                let loader = $(this.$el)
+                let param = ''
+
+                if (more) {
+                    param = '?page=' + (this.page + 1)
+                    loader = $('#payments-loader')
+                }
+
+                this.$root.addLoader(loader)
+                axios.get('/api/v4/payments/pending' + param)
+                    .then(response => {
+                        this.$root.removeLoader(loader)
+                        // Note: In Vue we can't just use .concat()
+                        for (let i in response.data.list) {
+                            this.$set(this.payments, this.payments.length, response.data.list[i])
+                        }
+                        this.hasMore = response.data.hasMore
+                        this.page = response.data.page || 1
+                    })
+                    .catch(error => {
+                        this.$root.removeLoader(loader)
+                    })
+            },
+            amount(payment) {
+                return this.$root.price(payment.amount)
+            }
+        }
+    }
+</script>
diff --git a/src/routes/api.php b/src/routes/api.php
index 86c4eaeb..b9c906dc 100644
--- a/src/routes/api.php
+++ b/src/routes/api.php
@@ -1,162 +1,166 @@
 <?php
 
 use Illuminate\Http\Request;
 
 /*
 |--------------------------------------------------------------------------
 | API Routes
 |--------------------------------------------------------------------------
 |
 | Here is where you can register API routes for your application. These
 | routes are loaded by the RouteServiceProvider within a group which
 | is assigned the "api" middleware group. Enjoy building your API!
 |
 */
 
 $prefix = \trim(\parse_url(\config('app.url'), PHP_URL_PATH), '/') . '/';
 
 Route::group(
     [
         'middleware' => 'api',
         'prefix' => $prefix . 'api/auth'
     ],
     function ($router) {
         Route::post('login', 'API\AuthController@login');
 
         Route::group(
             ['middleware' => 'auth:api'],
             function ($router) {
                 Route::get('info', 'API\AuthController@info');
                 Route::post('logout', 'API\AuthController@logout');
                 Route::post('refresh', 'API\AuthController@refresh');
             }
         );
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
         'middleware' => 'api',
         'prefix' => $prefix . 'api/auth'
     ],
     function ($router) {
         Route::post('password-reset/init', 'API\PasswordResetController@init');
         Route::post('password-reset/verify', 'API\PasswordResetController@verify');
         Route::post('password-reset', 'API\PasswordResetController@reset');
 
         Route::get('signup/plans', 'API\SignupController@plans');
         Route::post('signup/init', 'API\SignupController@init');
         Route::post('signup/verify', 'API\SignupController@verify');
         Route::post('signup', 'API\SignupController@signup');
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
         'middleware' => 'auth:api',
         'prefix' => $prefix . 'api/v4'
     ],
     function () {
         Route::apiResource('domains', API\V4\DomainsController::class);
         Route::get('domains/{id}/confirm', 'API\V4\DomainsController@confirm');
         Route::get('domains/{id}/status', 'API\V4\DomainsController@status');
 
         Route::apiResource('entitlements', API\V4\EntitlementsController::class);
         Route::apiResource('packages', API\V4\PackagesController::class);
         Route::apiResource('skus', API\V4\SkusController::class);
         Route::apiResource('users', API\V4\UsersController::class);
         Route::get('users/{id}/skus', 'API\V4\SkusController@userSkus');
         Route::get('users/{id}/status', 'API\V4\UsersController@status');
 
         Route::apiResource('wallets', API\V4\WalletsController::class);
         Route::get('wallets/{id}/transactions', 'API\V4\WalletsController@transactions');
         Route::get('wallets/{id}/receipts', 'API\V4\WalletsController@receipts');
         Route::get('wallets/{id}/receipts/{receipt}', 'API\V4\WalletsController@receiptDownload');
 
         Route::post('payments', 'API\V4\PaymentsController@store');
+        //Route::delete('payments', 'API\V4\PaymentsController@cancel');
         Route::get('payments/mandate', 'API\V4\PaymentsController@mandate');
         Route::post('payments/mandate', 'API\V4\PaymentsController@mandateCreate');
         Route::put('payments/mandate', 'API\V4\PaymentsController@mandateUpdate');
         Route::delete('payments/mandate', 'API\V4\PaymentsController@mandateDelete');
+        Route::get('payments/methods', 'API\V4\PaymentsController@paymentMethods');
+        Route::get('payments/pending', 'API\V4\PaymentsController@payments');
+        Route::get('payments/has-pending', 'API\V4\PaymentsController@hasPayments');
 
         Route::get('openvidu/rooms', 'API\V4\OpenViduController@index');
         Route::post('openvidu/rooms/{id}/close', 'API\V4\OpenViduController@closeRoom');
         Route::post('openvidu/rooms/{id}/config', 'API\V4\OpenViduController@setRoomConfig');
 
         // FIXME: I'm not sure about this one, should we use DELETE request maybe?
         Route::post('openvidu/rooms/{id}/connections/{conn}/dismiss', 'API\V4\OpenViduController@dismissConnection');
         Route::put('openvidu/rooms/{id}/connections/{conn}', 'API\V4\OpenViduController@updateConnection');
         Route::post('openvidu/rooms/{id}/request/{reqid}/accept', 'API\V4\OpenViduController@acceptJoinRequest');
         Route::post('openvidu/rooms/{id}/request/{reqid}/deny', 'API\V4\OpenViduController@denyJoinRequest');
     }
 );
 
 // Note: In Laravel 7.x we could just use withoutMiddleware() instead of a separate group
 Route::group(
     [
         'domain' => \config('app.domain'),
         'prefix' => $prefix . 'api/v4'
     ],
     function () {
         Route::post('openvidu/rooms/{id}', 'API\V4\OpenViduController@joinRoom');
         Route::post('openvidu/rooms/{id}/connections', 'API\V4\OpenViduController@createConnection');
         // FIXME: I'm not sure about this one, should we use DELETE request maybe?
         Route::post('openvidu/rooms/{id}/connections/{conn}/dismiss', 'API\V4\OpenViduController@dismissConnection');
         Route::put('openvidu/rooms/{id}/connections/{conn}', 'API\V4\OpenViduController@updateConnection');
         Route::post('openvidu/rooms/{id}/request/{reqid}/accept', 'API\V4\OpenViduController@acceptJoinRequest');
         Route::post('openvidu/rooms/{id}/request/{reqid}/deny', 'API\V4\OpenViduController@denyJoinRequest');
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
         'middleware' => 'api',
         'prefix' => $prefix . 'api/v4'
     ],
     function ($router) {
         Route::post('support/request', 'API\V4\SupportController@request');
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
         'prefix' => $prefix . 'api/webhooks',
     ],
     function () {
         Route::post('payment/{provider}', 'API\V4\PaymentsController@webhook');
         Route::post('meet/openvidu', 'API\V4\OpenViduController@webhook');
     }
 );
 
 Route::group(
     [
         'domain' => 'admin.' . \config('app.domain'),
         'middleware' => ['auth:api', 'admin'],
         'prefix' => $prefix . 'api/v4',
     ],
     function () {
         Route::apiResource('domains', API\V4\Admin\DomainsController::class);
         Route::get('domains/{id}/confirm', 'API\V4\Admin\DomainsController@confirm');
         Route::post('domains/{id}/suspend', 'API\V4\Admin\DomainsController@suspend');
         Route::post('domains/{id}/unsuspend', 'API\V4\Admin\DomainsController@unsuspend');
 
         Route::apiResource('entitlements', API\V4\Admin\EntitlementsController::class);
         Route::apiResource('packages', API\V4\Admin\PackagesController::class);
         Route::apiResource('skus', API\V4\Admin\SkusController::class);
         Route::apiResource('users', API\V4\Admin\UsersController::class);
         Route::post('users/{id}/reset2FA', 'API\V4\Admin\UsersController@reset2FA');
         Route::get('users/{id}/skus', 'API\V4\Admin\SkusController@userSkus');
         Route::post('users/{id}/suspend', 'API\V4\Admin\UsersController@suspend');
         Route::post('users/{id}/unsuspend', 'API\V4\Admin\UsersController@unsuspend');
         Route::apiResource('wallets', API\V4\Admin\WalletsController::class);
         Route::post('wallets/{id}/one-off', 'API\V4\Admin\WalletsController@oneOff');
         Route::get('wallets/{id}/transactions', 'API\V4\Admin\WalletsController@transactions');
         Route::apiResource('discounts', API\V4\Admin\DiscountsController::class);
 
         Route::get('stats/chart/{chart}', 'API\V4\Admin\StatsController@chart');
     }
 );
diff --git a/src/tests/Browser/PaymentMollieTest.php b/src/tests/Browser/PaymentMollieTest.php
index c12b759b..27018d3f 100644
--- a/src/tests/Browser/PaymentMollieTest.php
+++ b/src/tests/Browser/PaymentMollieTest.php
@@ -1,315 +1,313 @@
 <?php
 
 namespace Tests\Browser;
 
 use App\Providers\PaymentProvider;
 use App\Wallet;
 use Tests\Browser;
 use Tests\Browser\Components\Dialog;
 use Tests\Browser\Components\Toast;
 use Tests\Browser\Pages\Dashboard;
 use Tests\Browser\Pages\Home;
 use Tests\Browser\Pages\PaymentMollie;
 use Tests\Browser\Pages\Wallet as WalletPage;
 use Tests\TestCaseDusk;
 
 class PaymentMollieTest extends TestCaseDusk
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('payment-test@kolabnow.com');
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('payment-test@kolabnow.com');
 
         parent::tearDown();
     }
 
     /**
      * Test the payment process
      *
      * @group mollie
      */
     public function testPayment(): void
     {
         $user = $this->getTestUser('payment-test@kolabnow.com', [
                 'password' => 'simple123',
         ]);
 
         $this->browse(function (Browser $browser) use ($user) {
             $browser->visit(new Home())
                 ->submitLogon('payment-test@kolabnow.com', 'simple123', true, ['paymentProvider' => 'mollie'])
                 ->on(new Dashboard())
                 ->click('@links .link-wallet')
                 ->on(new WalletPage())
                 ->assertSeeIn('@main button', 'Add credit')
                 ->click('@main button')
+                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
+                    $browser->assertSeeIn('@title', 'Top up your wallet')
+                        ->waitFor('#payment-method-selection #creditcard')
+                        ->waitFor('#payment-method-selection #paypal')
+                        ->assertMissing('#payment-method-selection #banktransfer')
+                        ->click('#creditcard');
+                })
                 ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
                     $browser->assertSeeIn('@title', 'Top up your wallet')
                         ->assertFocused('#amount')
                         ->assertSeeIn('@button-cancel', 'Cancel')
-                        ->assertSeeIn('@body #payment-form button', 'Continue')
+                        ->assertSeeIn('@button-action', 'Continue')
                         // Test error handling
                         ->type('@body #amount', 'aaa')
-                        ->click('@body #payment-form button')
+                        ->click('@button-action')
                         ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
                         ->assertSeeIn('#amount + span + .invalid-feedback', 'The amount must be a number.')
                         // Submit valid data
                         ->type('@body #amount', '12.34')
                         // Note we use double click to assert it does not create redundant requests
-                        ->click('@body #payment-form button')
-                        ->click('@body #payment-form button');
+                        ->click('@button-action')
+                        ->click('@button-action');
                 })
                 ->on(new PaymentMollie())
                 ->assertSeeIn('@title', \config('app.name') . ' Payment')
                 ->assertSeeIn('@amount', 'CHF 12.34');
 
             $this->assertSame(1, $user->wallets()->first()->payments()->count());
 
             // Looks like the Mollie testing mode is limited.
             // We'll select credit card method and mark the payment as paid
             // We can't do much more, we have to trust Mollie their page works ;)
 
             // For some reason I don't get the method selection form, it
             // immediately jumps to the next step. Let's detect that
             if ($browser->element('@methods')) {
                 $browser->click('@methods button.grid-button-creditcard')
                     ->waitFor('button.form__button');
             }
 
             $browser->click('@status-table input[value="paid"]')
                 ->click('button.form__button');
 
             // Now it should redirect back to wallet page and in background
             // use the webhook to update payment status (and balance).
 
             // Looks like in test-mode the webhook is executed before redirect
             // so we can expect balance updated on the wallet page
 
             $browser->waitForLocation('/wallet')
                 ->on(new WalletPage())
                 ->assertSeeIn('@main .card-title', 'Account balance 12,34 CHF');
         });
     }
 
     /**
      * Test the auto-payment setup process
      *
      * @group mollie
      */
     public function testAutoPaymentSetup(): void
     {
         $user = $this->getTestUser('payment-test@kolabnow.com', [
                 'password' => 'simple123',
         ]);
 
         $this->browse(function (Browser $browser) use ($user) {
             $browser->visit(new Home())
                 ->submitLogon('payment-test@kolabnow.com', 'simple123', true, ['paymentProvider' => 'mollie'])
                 ->on(new Dashboard())
                 ->click('@links .link-wallet')
                 ->on(new WalletPage())
-                ->click('@main button')
+                ->assertMissing('@body #mandate-form .alert')
+                ->click('@main #mandate-form button')
                 ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $browser->assertSeeIn('@title', 'Top up your wallet')
-                        ->assertSeeIn('@button-cancel', 'Cancel')
-                        ->assertSeeIn('@body #mandate-form button', 'Set up auto-payment')
-                        ->assertSeeIn('@body #mandate-form p', 'Add auto-payment, so you never')
-                        ->assertMissing('@body #mandate-form .alert')
-                        ->click('@body #mandate-form button')
-                        ->assertSeeIn('@title', 'Add auto-payment')
+                    $browser->assertSeeIn('@title', 'Add auto-payment')
+                        ->waitFor('#payment-method-selection #creditcard')
+                        ->assertMissing('#payment-method-selection #paypal')
+                        ->assertMissing('#payment-method-selection #banktransfer')
+                        ->click('#creditcard');
+                })
+                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
+                    $browser->assertSeeIn('@title', 'Add auto-payment')
                         ->assertSeeIn('@body label[for="mandate_amount"]', 'Fill up by')
                         ->assertValue('@body #mandate_amount', PaymentProvider::MIN_AMOUNT / 100)
                         ->assertSeeIn('@body label[for="mandate_balance"]', 'when account balance is below') // phpcs:ignore
                         ->assertValue('@body #mandate_balance', '0')
                         ->assertSeeIn('@button-cancel', 'Cancel')
                         ->assertSeeIn('@button-action', 'Continue')
                         // Test error handling
                         ->type('@body #mandate_amount', 'aaa')
                         ->type('@body #mandate_balance', '-1')
                         ->click('@button-action')
                         ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
                         ->assertVisible('@body #mandate_amount.is-invalid')
                         ->assertVisible('@body #mandate_balance.is-invalid')
                         ->assertSeeIn('#mandate_amount + span + .invalid-feedback', 'The amount must be a number.')
                         ->assertSeeIn('#mandate_balance + span + .invalid-feedback', 'The balance must be at least 0.')
                         ->type('@body #mandate_amount', 'aaa')
                         ->type('@body #mandate_balance', '0')
                         ->click('@button-action')
                         ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
                         ->assertVisible('@body #mandate_amount.is-invalid')
                         ->assertMissing('@body #mandate_balance.is-invalid')
                         ->assertSeeIn('#mandate_amount + span + .invalid-feedback', 'The amount must be a number.')
                         ->assertMissing('#mandate_balance + span + .invalid-feedback')
                         // Submit valid data
                         ->type('@body #mandate_amount', '100')
                         ->type('@body #mandate_balance', '0')
                         // Note we use double click to assert it does not create redundant requests
                         ->click('@button-action')
                         ->click('@button-action');
                 })
                 ->on(new PaymentMollie())
                 ->assertSeeIn('@title', \config('app.name') . ' Auto-Payment Setup')
                 ->assertMissing('@amount')
                 ->submitValidCreditCard()
                 ->waitForLocation('/wallet')
                 ->visit('/wallet?paymentProvider=mollie')
-                ->on(new WalletPage())
-                ->click('@main button')
-                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $expected = 'Auto-payment is set to fill up your account by 100 CHF every'
-                        . ' time your account balance gets under 0 CHF. You will be charged'
-                        . ' via Mastercard (**** **** **** 6787).';
-
-                    $browser->assertSeeIn('@title', 'Top up your wallet')
-                        ->waitFor('#mandate-info')
-                        ->assertSeeIn('#mandate-info p:first-child', $expected)
-                        ->assertMissing('@body .alert')
-                        ->click('@button-cancel');
-                });
+                ->waitFor('#mandate-info')
+                ->assertPresent('#mandate-info p:first-child')
+                ->assertSeeIn(
+                    '#mandate-info p:first-child',
+                    'Auto-payment is set to fill up your account by 100 CHF ' .
+                    'every time your account balance gets under 0 CHF.'
+                )
+                ->assertSeeIn(
+                    '#mandate-info p:nth-child(2)',
+                    'Mastercard (**** **** **** 6787)'
+                )
+                ->assertMissing('@body .alert');
 
             $this->assertSame(1, $user->wallets()->first()->payments()->count());
         });
 
         // Test updating (disabled) auto-payment
         $this->browse(function (Browser $browser) use ($user) {
             $wallet = $user->wallets()->first();
             $wallet->setSetting('mandate_disabled', 1);
 
             $browser->refresh()
                 ->on(new WalletPage())
-                ->click('@main button')
+                ->waitFor('#mandate-info')
+                ->assertSeeIn(
+                    '#mandate-info .disabled-mandate',
+                    'The configured auto-payment has been disabled'
+                )
+                ->assertSeeIn('#mandate-info button.btn-primary', 'Change auto-payment')
+                ->click('#mandate-info button.btn-primary')
                 ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $browser->waitFor('@body #mandate-info')
-                        ->assertSeeIn(
-                            '@body #mandate-info .disabled-mandate',
-                            'The configured auto-payment has been disabled'
-                        )
-                        ->assertSeeIn('@body #mandate-info button.btn-primary', 'Change auto-payment')
-                        ->click('@body #mandate-info button.btn-primary')
-                        ->assertSeeIn('@title', 'Update auto-payment')
-                        ->assertSeeIn(
-                            '@body form .disabled-mandate',
-                            'The auto-payment is disabled.'
-                        )
-                        ->assertValue('@body #mandate_amount', '100')
-                        ->assertValue('@body #mandate_balance', '0')
-                        ->assertSeeIn('@button-cancel', 'Cancel')
-                        ->assertSeeIn('@button-action', 'Submit')
-                        // Test error handling
-                        ->type('@body #mandate_amount', 'aaa')
-                        ->click('@button-action')
-                        ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
-                        ->assertVisible('@body #mandate_amount.is-invalid')
-                        ->assertSeeIn('#mandate_amount + span + .invalid-feedback', 'The amount must be a number.')
-                        // Submit valid data
-                        ->type('@body #mandate_amount', '50')
-                        ->click('@button-action');
+                    $browser->assertSeeIn('@title', 'Update auto-payment')
+                    ->assertSeeIn(
+                        '@body form .disabled-mandate',
+                        'The auto-payment is disabled.'
+                    )
+                    ->assertValue('@body #mandate_amount', '100')
+                    ->assertValue('@body #mandate_balance', '0')
+                    ->assertSeeIn('@button-cancel', 'Cancel')
+                    ->assertSeeIn('@button-action', 'Submit')
+                    // Test error handling
+                    ->type('@body #mandate_amount', 'aaa')
+                    ->click('@button-action')
+                    ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
+                    ->assertVisible('@body #mandate_amount.is-invalid')
+                    ->assertSeeIn('#mandate_amount + span + .invalid-feedback', 'The amount must be a number.')
+                    // Submit valid data
+                    ->type('@body #mandate_amount', '50')
+                    ->click('@button-action');
                 })
                 ->waitUntilMissing('#payment-dialog')
                 ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been updated.')
-                // Open the dialog again and make sure the "disabled" text isn't there
-                ->click('@main button')
-                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $browser->assertMissing('@body #mandate-info .disabled-mandate')
-                        ->click('@body #mandate-info button.btn-primary')
-                        ->assertMissing('@body form .disabled-mandate')
-                        ->click('@button-cancel');
-                });
+                // make sure the "disabled" text isn't there
+                ->assertMissing('#mandate-info .disabled-mandate')
+                ->click('#mandate-info button.btn-primary')
+                ->assertMissing('form .disabled-mandate')
+                ->click('button.modal-cancel');
         });
 
         // Test deleting auto-payment
         $this->browse(function (Browser $browser) {
             $browser->on(new WalletPage())
-                ->click('@main button')
-                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $browser->assertSeeIn('@body #mandate-info button.btn-danger', 'Cancel auto-payment')
-                        ->click('@body #mandate-info button.btn-danger')
-                        ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been removed.')
-                        ->assertVisible('@body #mandate-form')
-                        ->assertMissing('@body #mandate-info')
-                        ->click('@button-cancel');
-                });
+            ->waitFor('#mandate-info')
+            ->assertSeeIn('#mandate-info * button.btn-danger', 'Cancel auto-payment')
+            ->assertVisible('#mandate-info * button.btn-danger')
+            ->click('#mandate-info * button.btn-danger')
+            ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been removed.')
+            ->assertVisible('#mandate-form')
+            ->assertMissing('#mandate-info');
         });
 
         // Test pending and failed mandate
         $this->browse(function (Browser $browser) {
             $browser->on(new WalletPage())
-                ->click('@main button')
+                ->assertMissing('@body #mandate-form .alert')
+                ->click('@main #mandate-form button')
                 ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $browser->assertSeeIn('@title', 'Top up your wallet')
+                    $browser->assertSeeIn('@title', 'Add auto-payment')
+                        ->waitFor('#payment-method-selection #creditcard')
+                        ->click('#creditcard');
+                })
+                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
+                    $browser->assertSeeIn('@title', 'Add auto-payment')
                         ->assertSeeIn('@button-cancel', 'Cancel')
-                        ->assertSeeIn('@body #mandate-form button', 'Set up auto-payment')
-                        ->assertSeeIn('@body #mandate-form p', 'Add auto-payment, so you never')
-                        ->assertMissing('@body #mandate-form .alert')
-                        ->click('@body #mandate-form button')
-                        ->assertSeeIn('@title', 'Add auto-payment')
-                        ->assertMissing('@body .alert')
+                        ->assertSeeIn('@button-action', 'Continue')
                         // Submit valid data
                         ->type('@body #mandate_amount', '100')
                         ->type('@body #mandate_balance', '0')
                         ->click('@button-action');
                 })
                 ->on(new PaymentMollie())
                 ->submitValidCreditCard('open')
                 ->waitForLocation('/wallet')
                 ->visit('/wallet?paymentProvider=mollie')
                 ->on(new WalletPage())
-                ->click('@main button')
-                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $expected = 'Auto-payment is set to fill up your account by 100 CHF every'
-                        . ' time your account balance gets under 0 CHF. You will be charged'
-                        . ' via Credit Card.';
+                ->assertSeeIn(
+                    '#mandate-info .alert-warning',
+                    'The setup of the automatic payment is still in progress.'
+                )
+                // Delete the mandate
+                ->click('#mandate-info * button.btn-danger')
+                ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been removed.')
+                ->assertMissing('@body #mandate-form .alert')
 
-                    $browser->assertSeeIn('@title', 'Top up your wallet')
-                        ->waitFor('#mandate-info')
-                        ->assertSeeIn('#mandate-info p:first-child', $expected)
-                        ->assertSeeIn(
-                            '#mandate-info .alert-warning',
-                            'The setup of the automatic payment is still in progress.'
-                        )
-                        ->assertSeeIn('@body #mandate-info .btn-danger', 'Cancel auto-payment')
-                        ->assertSeeIn('@body #mandate-info .btn-primary', 'Change auto-payment')
-                        // Delete the mandate
-                        ->click('@body #mandate-info .btn-danger')
-                        ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been removed.')
-                        ->assertSeeIn('@body #mandate-form p', 'Add auto-payment, so you never')
-                        ->assertMissing('@body #mandate-form .alert')
-                        ->click('@body #mandate-form button')
-                        ->assertSeeIn('@title', 'Add auto-payment')
-                        ->assertMissing('@body .alert')
+                // Create a new mandate
+                ->click('@main #mandate-form button')
+                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
+                    $browser->assertSeeIn('@title', 'Add auto-payment')
+                        ->waitFor('#payment-method-selection #creditcard')
+                        ->click('#creditcard');
+                })
+                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
+                    $browser->assertSeeIn('@title', 'Add auto-payment')
+                        ->assertSeeIn('@button-cancel', 'Cancel')
+                        ->assertSeeIn('@button-action', 'Continue')
                         // Submit valid data
                         ->type('@body #mandate_amount', '100')
                         ->type('@body #mandate_balance', '0')
                         ->click('@button-action');
                 })
                 ->on(new PaymentMollie())
                 ->submitValidCreditCard('failed')
                 ->waitForLocation('/wallet')
                 ->visit('/wallet?paymentProvider=mollie')
                 ->on(new WalletPage())
+                ->waitFor('#mandate-form .alert-danger')
+                ->assertSeeIn(
+                    '#mandate-form .alert-danger',
+                    'The setup of automatic payments failed. Restart the process to enable'
+                )
                 ->click('@main button')
                 ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
                     $browser->waitFor('#mandate-form')
-                        ->assertMissing('#mandate-info')
-                        ->assertSeeIn('#mandate-form p', 'Add auto-payment')
-                        ->waitFor('#mandate-form .alert-danger')
-                        ->assertSeeIn(
-                            '#mandate-form .alert-danger',
-                            'The setup of automatic payments failed. Restart the process to enable'
-                        )
-                        ->assertSeeIn('@body #mandate-form .btn-primary', 'Set up auto-payment');
+                        ->assertMissing('#mandate-info');
                 });
         });
     }
 }
diff --git a/src/tests/Browser/PaymentStripeTest.php b/src/tests/Browser/PaymentStripeTest.php
index c37e47aa..5bb34510 100644
--- a/src/tests/Browser/PaymentStripeTest.php
+++ b/src/tests/Browser/PaymentStripeTest.php
@@ -1,202 +1,234 @@
 <?php
 
 namespace Tests\Browser;
 
 use App\Providers\PaymentProvider;
 use App\Wallet;
 use Tests\Browser;
 use Tests\Browser\Components\Dialog;
 use Tests\Browser\Components\Toast;
 use Tests\Browser\Pages\Dashboard;
 use Tests\Browser\Pages\Home;
 use Tests\Browser\Pages\PaymentStripe;
 use Tests\Browser\Pages\Wallet as WalletPage;
 use Tests\TestCaseDusk;
 
 class PaymentStripeTest extends TestCaseDusk
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('payment-test@kolabnow.com');
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('payment-test@kolabnow.com');
 
         parent::tearDown();
     }
 
     /**
      * Test the payment process
      *
      * @group stripe
      */
     public function testPayment(): void
     {
         $user = $this->getTestUser('payment-test@kolabnow.com', [
                 'password' => 'simple123',
         ]);
 
         $this->browse(function (Browser $browser) use ($user) {
             $browser->visit(new Home())
                 ->submitLogon('payment-test@kolabnow.com', 'simple123', true, ['paymentProvider' => 'stripe'])
                 ->on(new Dashboard())
                 ->click('@links .link-wallet')
                 ->on(new WalletPage())
                 ->assertSeeIn('@main button', 'Add credit')
                 ->click('@main button')
+                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
+                    $browser->assertSeeIn('@title', 'Top up your wallet')
+                        ->waitFor('#payment-method-selection #creditcard')
+                        ->waitFor('#payment-method-selection #paypal')
+                        ->assertMissing('#payment-method-selection #banktransfer')
+                        ->click('#creditcard');
+                })
                 ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
                     $browser->assertSeeIn('@title', 'Top up your wallet')
                         ->assertFocused('#amount')
                         ->assertSeeIn('@button-cancel', 'Cancel')
-                        ->assertSeeIn('@body #payment-form button', 'Continue')
+                        ->assertSeeIn('@button-action', 'Continue')
                         // Test error handling
                         ->type('@body #amount', 'aaa')
-                        ->click('@body #payment-form button')
+                        ->click('@button-action')
                         ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
                         ->assertSeeIn('#amount + span + .invalid-feedback', 'The amount must be a number.')
                         // Submit valid data
                         ->type('@body #amount', '12.34')
-                        ->click('@body #payment-form button');
+                        // Note we use double click to assert it does not create redundant requests
+                        ->click('@button-action')
+                        ->click('@button-action');
                 })
                 ->on(new PaymentStripe())
                 ->assertSeeIn('@title', \config('app.name') . ' Payment')
                 ->assertSeeIn('@amount', 'CHF 12.34')
                 ->assertValue('@email-input', $user->email)
                 ->submitValidCreditCard();
 
             // Now it should redirect back to wallet page and in background
             // use the webhook to update payment status (and balance).
 
             // Looks like in test-mode the webhook is executed before redirect
             // so we can expect balance updated on the wallet page
 
             $browser->waitForLocation('/wallet', 30) // need more time than default 5 sec.
                 ->on(new WalletPage())
                 ->assertSeeIn('@main .card-title', 'Account balance 12,34 CHF');
         });
     }
 
     /**
      * Test the auto-payment setup process
      *
      * @group stripe
      */
     public function testAutoPaymentSetup(): void
     {
         $user = $this->getTestUser('payment-test@kolabnow.com', [
                 'password' => 'simple123',
         ]);
 
         // Test creating auto-payment
         $this->browse(function (Browser $browser) use ($user) {
             $browser->visit(new Home())
                 ->submitLogon('payment-test@kolabnow.com', 'simple123', true, ['paymentProvider' => 'stripe'])
                 ->on(new Dashboard())
                 ->click('@links .link-wallet')
                 ->on(new WalletPage())
-                ->click('@main button')
+                ->assertMissing('@body #mandate-form .alert')
+                ->click('@main #mandate-form button')
                 ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $browser->assertSeeIn('@title', 'Top up your wallet')
-                        ->assertSeeIn('@button-cancel', 'Cancel')
-                        ->assertSeeIn('@body #mandate-form button', 'Set up auto-payment')
-                        ->click('@body #mandate-form button')
-                        ->assertSeeIn('@title', 'Add auto-payment')
+                    $browser->assertSeeIn('@title', 'Add auto-payment')
+                        ->waitFor('#payment-method-selection #creditcard')
+                        ->assertMissing('#payment-method-selection #paypal')
+                        ->assertMissing('#payment-method-selection #banktransfer')
+                        ->click('#creditcard');
+                })
+                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
+                    $browser->assertSeeIn('@title', 'Add auto-payment')
                         ->assertSeeIn('@body label[for="mandate_amount"]', 'Fill up by')
                         ->assertValue('@body #mandate_amount', PaymentProvider::MIN_AMOUNT / 100)
                         ->assertSeeIn('@body label[for="mandate_balance"]', 'when account balance is below') // phpcs:ignore
                         ->assertValue('@body #mandate_balance', '0')
                         ->assertSeeIn('@button-cancel', 'Cancel')
                         ->assertSeeIn('@button-action', 'Continue')
                         // Test error handling
                         ->type('@body #mandate_amount', 'aaa')
                         ->type('@body #mandate_balance', '-1')
                         ->click('@button-action')
                         ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
                         ->assertVisible('@body #mandate_amount.is-invalid')
                         ->assertVisible('@body #mandate_balance.is-invalid')
                         ->assertSeeIn('#mandate_amount + span + .invalid-feedback', 'The amount must be a number.')
                         ->assertSeeIn('#mandate_balance + span + .invalid-feedback', 'The balance must be at least 0.')
                         ->type('@body #mandate_amount', 'aaa')
                         ->type('@body #mandate_balance', '0')
                         ->click('@button-action')
                         ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
                         ->assertVisible('@body #mandate_amount.is-invalid')
                         ->assertMissing('@body #mandate_balance.is-invalid')
                         ->assertSeeIn('#mandate_amount + span + .invalid-feedback', 'The amount must be a number.')
                         ->assertMissing('#mandate_balance + span + .invalid-feedback')
                         // Submit valid data
                         ->type('@body #mandate_amount', '100')
                         ->type('@body #mandate_balance', '0')
+                        // Note we use double click to assert it does not create redundant requests
+                        ->click('@button-action')
                         ->click('@button-action');
                 })
                 ->on(new PaymentStripe())
                 ->assertMissing('@title')
                 ->assertMissing('@amount')
                 ->assertValue('@email-input', $user->email)
                 ->submitValidCreditCard()
                 ->waitForLocation('/wallet', 30) // need more time than default 5 sec.
                 ->visit('/wallet?paymentProvider=stripe')
-                ->on(new WalletPage())
-                ->click('@main button')
-                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $expected = 'Auto-payment is set to fill up your account by 100 CHF every'
-                        . ' time your account balance gets under 0 CHF. You will be charged'
-                        . ' via Visa (**** **** **** 4242).';
-
-                    $browser->assertSeeIn('@title', 'Top up your wallet')
-                        ->waitFor('#mandate-info')
-                        ->assertSeeIn('#mandate-info p:first-child', $expected)
-                        ->click('@button-cancel');
-                });
+                ->waitFor('#mandate-info')
+                ->assertPresent('#mandate-info p:first-child')
+                ->assertSeeIn(
+                    '#mandate-info p:first-child',
+                    'Auto-payment is set to fill up your account by 100 CHF ' .
+                    'every time your account balance gets under 0 CHF.'
+                )
+                ->assertSeeIn(
+                    '#mandate-info p:nth-child(2)',
+                    'Visa (**** **** **** 4242)'
+                )
+                ->assertMissing('@body .alert');
         });
 
-        // Test updating auto-payment
-        $this->browse(function (Browser $browser) {
-            $browser->on(new WalletPage())
-                ->click('@main button')
+
+        // Test updating (disabled) auto-payment
+        $this->browse(function (Browser $browser) use ($user) {
+            $wallet = $user->wallets()->first();
+            $wallet->setSetting('mandate_disabled', 1);
+
+            $browser->refresh()
+                ->on(new WalletPage())
+                ->waitFor('#mandate-info')
+                ->assertSeeIn(
+                    '#mandate-info .disabled-mandate',
+                    'The configured auto-payment has been disabled'
+                )
+                ->assertSeeIn('#mandate-info button.btn-primary', 'Change auto-payment')
+                ->click('#mandate-info button.btn-primary')
                 ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $browser->assertSeeIn('@body #mandate-info button.btn-primary', 'Change auto-payment')
-                        ->click('@body #mandate-info button.btn-primary')
-                        ->assertSeeIn('@title', 'Update auto-payment')
-                        ->assertValue('@body #mandate_amount', '100')
-                        ->assertValue('@body #mandate_balance', '0')
-                        ->assertSeeIn('@button-cancel', 'Cancel')
-                        ->assertSeeIn('@button-action', 'Submit')
-                        // Test error handling
-                        ->type('@body #mandate_amount', 'aaa')
-                        ->click('@button-action')
-                        ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
-                        ->assertVisible('@body #mandate_amount.is-invalid')
-                        ->assertSeeIn('#mandate_amount + span + .invalid-feedback', 'The amount must be a number.')
-                        // Submit valid data
-                        ->type('@body #mandate_amount', '50')
-                        ->click('@button-action');
+                    $browser->assertSeeIn('@title', 'Update auto-payment')
+                    ->assertSeeIn(
+                        '@body form .disabled-mandate',
+                        'The auto-payment is disabled.'
+                    )
+                    ->assertValue('@body #mandate_amount', '100')
+                    ->assertValue('@body #mandate_balance', '0')
+                    ->assertSeeIn('@button-cancel', 'Cancel')
+                    ->assertSeeIn('@button-action', 'Submit')
+                    // Test error handling
+                    ->type('@body #mandate_amount', 'aaa')
+                    ->click('@button-action')
+                    ->assertToast(Toast::TYPE_ERROR, 'Form validation error')
+                    ->assertVisible('@body #mandate_amount.is-invalid')
+                    ->assertSeeIn('#mandate_amount + span + .invalid-feedback', 'The amount must be a number.')
+                    // Submit valid data
+                    ->type('@body #mandate_amount', '50')
+                    ->click('@button-action');
                 })
                 ->waitUntilMissing('#payment-dialog')
-                ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been updated.');
+                ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been updated.')
+                // make sure the "disabled" text isn't there
+                ->assertMissing('#mandate-info .disabled-mandate')
+                ->click('#mandate-info button.btn-primary')
+                ->assertMissing('form .disabled-mandate')
+                ->click('button.modal-cancel');
         });
 
         // Test deleting auto-payment
         $this->browse(function (Browser $browser) {
             $browser->on(new WalletPage())
-                ->click('@main button')
-                ->with(new Dialog('@payment-dialog'), function (Browser $browser) {
-                    $browser->assertSeeIn('@body #mandate-info button.btn-danger', 'Cancel auto-payment')
-                        ->click('@body #mandate-info button.btn-danger')
-                        ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been removed.')
-                        ->assertVisible('@body #mandate-form')
-                        ->assertMissing('@body #mandate-info');
-                });
+            ->waitFor('#mandate-info')
+            ->assertSeeIn('#mandate-info * button.btn-danger', 'Cancel auto-payment')
+            ->assertVisible('#mandate-info * button.btn-danger')
+            ->click('#mandate-info * button.btn-danger')
+            ->assertToast(Toast::TYPE_SUCCESS, 'The auto-payment has been removed.')
+            ->assertVisible('#mandate-form')
+            ->assertMissing('#mandate-info');
         });
     }
 }
diff --git a/src/tests/Feature/Controller/PaymentsMollieTest.php b/src/tests/Feature/Controller/PaymentsMollieTest.php
index ef77477a..bf053f35 100644
--- a/src/tests/Feature/Controller/PaymentsMollieTest.php
+++ b/src/tests/Feature/Controller/PaymentsMollieTest.php
@@ -1,815 +1,920 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\Http\Controllers\API\V4\PaymentsController;
 use App\Payment;
 use App\Providers\PaymentProvider;
 use App\Transaction;
 use App\Wallet;
 use App\WalletSetting;
 use GuzzleHttp\Psr7\Response;
 use Illuminate\Support\Facades\Bus;
 use Tests\TestCase;
 use Tests\BrowserAddonTrait;
 use Tests\MollieMocksTrait;
 
 class PaymentsMollieTest extends TestCase
 {
     use MollieMocksTrait;
     use BrowserAddonTrait;
 
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         // All tests in this file use Mollie
         \config(['services.payment_provider' => 'mollie']);
 
         $john = $this->getTestUser('john@kolab.org');
         $wallet = $john->wallets()->first();
         Payment::where('wallet_id', $wallet->id)->delete();
         Wallet::where('id', $wallet->id)->update(['balance' => 0]);
         WalletSetting::where('wallet_id', $wallet->id)->delete();
         $types = [
             Transaction::WALLET_CREDIT,
             Transaction::WALLET_REFUND,
             Transaction::WALLET_CHARGEBACK,
         ];
         Transaction::where('object_id', $wallet->id)->whereIn('type', $types)->delete();
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $wallet = $john->wallets()->first();
         Payment::where('wallet_id', $wallet->id)->delete();
         Wallet::where('id', $wallet->id)->update(['balance' => 0]);
         WalletSetting::where('wallet_id', $wallet->id)->delete();
         $types = [
             Transaction::WALLET_CREDIT,
             Transaction::WALLET_REFUND,
             Transaction::WALLET_CHARGEBACK,
         ];
         Transaction::where('object_id', $wallet->id)->whereIn('type', $types)->delete();
 
         parent::tearDown();
     }
 
     /**
      * Test creating/updating/deleting an outo-payment mandate
      *
      * @group mollie
      */
     public function testMandates(): void
     {
         // Unauth access not allowed
         $response = $this->get("api/v4/payments/mandate");
         $response->assertStatus(401);
         $response = $this->post("api/v4/payments/mandate", []);
         $response->assertStatus(401);
         $response = $this->put("api/v4/payments/mandate", []);
         $response->assertStatus(401);
         $response = $this->delete("api/v4/payments/mandate");
         $response->assertStatus(401);
 
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
 
         // Test creating a mandate (invalid input)
         $post = [];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json['errors']);
         $this->assertSame('The amount field is required.', $json['errors']['amount'][0]);
         $this->assertSame('The balance field is required.', $json['errors']['balance'][0]);
 
         // Test creating a mandate (invalid input)
         $post = ['amount' => 100, 'balance' => 'a'];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame('The balance must be a number.', $json['errors']['balance'][0]);
 
         // Test creating a mandate (amount smaller than the minimum value)
         $post = ['amount' => -100, 'balance' => 0];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $min = intval(PaymentProvider::MIN_AMOUNT / 100) . ' CHF';
         $this->assertSame("Minimum amount for a single payment is {$min}.", $json['errors']['amount']);
 
         // Test creating a mandate (negative balance, amount too small)
         Wallet::where('id', $wallet->id)->update(['balance' => -2000]);
         $post = ['amount' => PaymentProvider::MIN_AMOUNT / 100, 'balance' => 0];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame("The specified amount does not cover the balance on the account.", $json['errors']['amount']);
 
         // Test creating a mandate (valid input)
         $post = ['amount' => 20.10, 'balance' => 0];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertRegExp('|^https://www.mollie.com|', $json['redirectUrl']);
 
         // Assert the proper payment amount has been used
         $payment = Payment::where('id', $json['id'])->first();
         $this->assertSame(2010, $payment->amount);
         $this->assertSame($wallet->id, $payment->wallet_id);
-        $this->assertSame("Kolab Now Auto-Payment Setup", $payment->description);
+        $this->assertSame(\config('app.name') . " Auto-Payment Setup", $payment->description);
         $this->assertSame(PaymentProvider::TYPE_MANDATE, $payment->type);
 
         // Test fetching the mandate information
         $response = $this->actingAs($user)->get("api/v4/payments/mandate");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals(20.10, $json['amount']);
         $this->assertEquals(0, $json['balance']);
         $this->assertEquals('Credit Card', $json['method']);
         $this->assertSame(true, $json['isPending']);
         $this->assertSame(false, $json['isValid']);
         $this->assertSame(false, $json['isDisabled']);
 
         $mandate_id = $json['id'];
 
         // We would have to invoke a browser to accept the "first payment" to make
         // the mandate validated/completed. Instead, we'll mock the mandate object.
         $mollie_response = [
             'resource' => 'mandate',
             'id' => $mandate_id,
             'status' => 'valid',
             'method' => 'creditcard',
             'details' => [
                 'cardNumber' => '4242',
                 'cardLabel' => 'Visa',
             ],
             'customerId' => 'cst_GMfxGPt7Gj',
             'createdAt' => '2020-04-28T11:09:47+00:00',
         ];
 
         $responseStack = $this->mockMollie();
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $wallet = $user->wallets()->first();
         $wallet->setSetting('mandate_disabled', 1);
 
         $response = $this->actingAs($user)->get("api/v4/payments/mandate");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals(20.10, $json['amount']);
         $this->assertEquals(0, $json['balance']);
         $this->assertEquals('Visa (**** **** **** 4242)', $json['method']);
         $this->assertSame(false, $json['isPending']);
         $this->assertSame(true, $json['isValid']);
         $this->assertSame(true, $json['isDisabled']);
 
         Bus::fake();
         $wallet->setSetting('mandate_disabled', null);
         $wallet->balance = 1000;
         $wallet->save();
 
         // Test updating mandate details (invalid input)
         $post = [];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json['errors']);
         $this->assertSame('The amount field is required.', $json['errors']['amount'][0]);
         $this->assertSame('The balance field is required.', $json['errors']['balance'][0]);
 
         $post = ['amount' => -100, 'balance' => 0];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame("Minimum amount for a single payment is {$min}.", $json['errors']['amount']);
 
         // Test updating a mandate (valid input)
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $post = ['amount' => 30.10, 'balance' => 10];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('The auto-payment has been updated.', $json['message']);
         $this->assertSame($mandate_id, $json['id']);
         $this->assertFalse($json['isDisabled']);
 
         $wallet->refresh();
 
         $this->assertEquals(30.10, $wallet->getSetting('mandate_amount'));
         $this->assertEquals(10, $wallet->getSetting('mandate_balance'));
 
         Bus::assertDispatchedTimes(\App\Jobs\WalletCharge::class, 0);
 
         // Test updating a disabled mandate (invalid input)
         $wallet->setSetting('mandate_disabled', 1);
         $wallet->balance = -2000;
         $wallet->save();
         $user->refresh(); // required so the controller sees the wallet update from above
 
         $post = ['amount' => 15.10, 'balance' => 1];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame('The specified amount does not cover the balance on the account.', $json['errors']['amount']);
 
         // Test updating a disabled mandate (valid input)
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $post = ['amount' => 30, 'balance' => 1];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('The auto-payment has been updated.', $json['message']);
         $this->assertSame($mandate_id, $json['id']);
         $this->assertFalse($json['isDisabled']);
 
         Bus::assertDispatchedTimes(\App\Jobs\WalletCharge::class, 1);
         Bus::assertDispatched(\App\Jobs\WalletCharge::class, function ($job) use ($wallet) {
             $job_wallet = $this->getObjectProperty($job, 'wallet');
             return $job_wallet->id === $wallet->id;
         });
 
         $this->unmockMollie();
 
         // Delete mandate
         $response = $this->actingAs($user)->delete("api/v4/payments/mandate");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('The auto-payment has been removed.', $json['message']);
 
         // Confirm with Mollie the mandate does not exist
         $customer_id = $wallet->getSetting('mollie_id');
         $this->expectException(\Mollie\Api\Exceptions\ApiException::class);
         $this->expectExceptionMessageMatches('/410: Gone/');
         $mandate = mollie()->mandates()->getForId($customer_id, $mandate_id);
 
         $this->assertNull($wallet->fresh()->getSetting('mollie_mandate_id'));
 
         // Test Mollie's "410 Gone" response handling when fetching the mandate info
         // It is expected to remove the mandate reference
         $mollie_response = [
             'status' => 410,
             'title' => "Gone",
             'detail' => "You are trying to access an object, which has previously been deleted",
             '_links' => [
                 'documentation' => [
                     'href' => "https://docs.mollie.com/errors",
                     'type' => "text/html"
                 ]
             ]
         ];
 
         $responseStack = $this->mockMollie();
         $responseStack->append(new Response(410, [], json_encode($mollie_response)));
 
         $wallet->fresh()->setSetting('mollie_mandate_id', '123');
 
         $response = $this->actingAs($user)->get("api/v4/payments/mandate");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertFalse(array_key_exists('id', $json));
         $this->assertFalse(array_key_exists('method', $json));
         $this->assertNull($wallet->fresh()->getSetting('mollie_mandate_id'));
     }
 
     /**
      * Test creating a payment and receiving a status via webhook
      *
      * @group mollie
      */
     public function testStoreAndWebhook(): void
     {
         Bus::fake();
 
         // Unauth access not allowed
         $response = $this->post("api/v4/payments", []);
         $response->assertStatus(401);
 
+        // Invalid amount
         $user = $this->getTestUser('john@kolab.org');
 
         $post = ['amount' => -1];
         $response = $this->actingAs($user)->post("api/v4/payments", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $min = intval(PaymentProvider::MIN_AMOUNT / 100) . ' CHF';
         $this->assertSame("Minimum amount for a single payment is {$min}.", $json['errors']['amount']);
 
-        $post = ['amount' => '12.34'];
+        // Invalid currency
+        $post = ['amount' => '12.34', 'currency' => 'FOO', 'methodId' => 'creditcard'];
+        $response = $this->actingAs($user)->post("api/v4/payments", $post);
+        $response->assertStatus(500);
+
+        // Successful payment
+        $post = ['amount' => '12.34', 'currency' => 'CHF', 'methodId' => 'creditcard'];
         $response = $this->actingAs($user)->post("api/v4/payments", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertRegExp('|^https://www.mollie.com|', $json['redirectUrl']);
 
         $wallet = $user->wallets()->first();
         $payments = Payment::where('wallet_id', $wallet->id)->get();
 
         $this->assertCount(1, $payments);
         $payment = $payments[0];
         $this->assertSame(1234, $payment->amount);
         $this->assertSame(\config('app.name') . ' Payment', $payment->description);
         $this->assertSame('open', $payment->status);
         $this->assertEquals(0, $wallet->balance);
 
         // Test the webhook
         // Note: Webhook end-point does not require authentication
 
         $mollie_response = [
             "resource" => "payment",
             "id" => $payment->id,
             "status" => "paid",
             // Status is not enough, paidAt is used to distinguish the state
             "paidAt" => date('c'),
             "mode" => "test",
         ];
 
         // We'll trigger the webhook with payment id and use mocking for
         // a request to the Mollie payments API. We cannot force Mollie
         // to make the payment status change.
         $responseStack = $this->mockMollie();
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $post = ['id' => $payment->id];
         $response = $this->post("api/webhooks/payment/mollie", $post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->fresh()->status);
         $this->assertEquals(1234, $wallet->fresh()->balance);
 
         $transaction = $wallet->transactions()
             ->where('type', Transaction::WALLET_CREDIT)->get()->last();
 
         $this->assertSame(1234, $transaction->amount);
         $this->assertSame(
             "Payment transaction {$payment->id} using Mollie",
             $transaction->description
         );
 
         // Assert that email notification job wasn't dispatched,
         // it is expected only for recurring payments
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 0);
 
         // Verify "paid -> open -> paid" scenario, assert that balance didn't change
         $mollie_response['status'] = 'open';
         unset($mollie_response['paidAt']);
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $response = $this->post("api/webhooks/payment/mollie", $post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->fresh()->status);
         $this->assertEquals(1234, $wallet->fresh()->balance);
 
         $mollie_response['status'] = 'paid';
         $mollie_response['paidAt'] = date('c');
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $response = $this->post("api/webhooks/payment/mollie", $post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->fresh()->status);
         $this->assertEquals(1234, $wallet->fresh()->balance);
 
         // Test for payment failure
         Bus::fake();
 
         $payment->refresh();
         $payment->status = PaymentProvider::STATUS_OPEN;
         $payment->save();
 
         $mollie_response = [
             "resource" => "payment",
             "id" => $payment->id,
             "status" => "failed",
             "mode" => "test",
         ];
 
         // We'll trigger the webhook with payment id and use mocking for
         // a request to the Mollie payments API. We cannot force Mollie
         // to make the payment status change.
         $responseStack = $this->mockMollie();
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $response = $this->post("api/webhooks/payment/mollie", $post);
         $response->assertStatus(200);
 
         $this->assertSame('failed', $payment->fresh()->status);
         $this->assertEquals(1234, $wallet->fresh()->balance);
 
         // Assert that email notification job wasn't dispatched,
         // it is expected only for recurring payments
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 0);
     }
 
     /**
      * Test automatic payment charges
      *
      * @group mollie
      */
     public function testTopUp(): void
     {
         Bus::fake();
 
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
 
         // Create a valid mandate first (balance=0, so there's no extra payment yet)
         $this->createMandate($wallet, ['amount' => 20.10, 'balance' => 0]);
 
         $wallet->setSetting('mandate_balance', 10);
 
         // Expect a recurring payment as we have a valid mandate at this point
         // and the balance is below the threshold
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertTrue($result);
 
         // Check that the payments table contains a new record with proper amount.
         // There should be two records, one for the mandate payment and another for
         // the top-up payment
         $payments = $wallet->payments()->orderBy('amount')->get();
         $this->assertCount(2, $payments);
         $this->assertSame(0, $payments[0]->amount);
         $this->assertSame(2010, $payments[1]->amount);
         $payment = $payments[1];
 
         // In mollie we don't have to wait for a webhook, the response to
         // PaymentIntent already sets the status to 'paid', so we can test
         // immediately the balance update
         // Assert that email notification job has been dispatched
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->status);
         $this->assertEquals(2010, $wallet->fresh()->balance);
         $transaction = $wallet->transactions()
             ->where('type', Transaction::WALLET_CREDIT)->get()->last();
 
         $this->assertSame(2010, $transaction->amount);
         $this->assertSame(
             "Auto-payment transaction {$payment->id} using Mastercard (**** **** **** 6787)",
             $transaction->description
         );
 
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 1);
         Bus::assertDispatched(\App\Jobs\PaymentEmail::class, function ($job) use ($payment) {
             $job_payment = $this->getObjectProperty($job, 'payment');
             return $job_payment->id === $payment->id;
         });
 
         // Expect no payment if the mandate is disabled
         $wallet->setSetting('mandate_disabled', 1);
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertFalse($result);
         $this->assertCount(2, $wallet->payments()->get());
 
         // Expect no payment if balance is ok
         $wallet->setSetting('mandate_disabled', null);
         $wallet->balance = 1000;
         $wallet->save();
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertFalse($result);
         $this->assertCount(2, $wallet->payments()->get());
 
         // Expect no payment if the top-up amount is not enough
         $wallet->setSetting('mandate_disabled', null);
         $wallet->balance = -2050;
         $wallet->save();
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertFalse($result);
         $this->assertCount(2, $wallet->payments()->get());
 
         Bus::assertDispatchedTimes(\App\Jobs\PaymentMandateDisabledEmail::class, 1);
         Bus::assertDispatched(\App\Jobs\PaymentMandateDisabledEmail::class, function ($job) use ($wallet) {
             $job_wallet = $this->getObjectProperty($job, 'wallet');
             return $job_wallet->id === $wallet->id;
         });
 
         // Expect no payment if there's no mandate
         $wallet->setSetting('mollie_mandate_id', null);
         $wallet->balance = 0;
         $wallet->save();
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertFalse($result);
         $this->assertCount(2, $wallet->payments()->get());
 
         Bus::assertDispatchedTimes(\App\Jobs\PaymentMandateDisabledEmail::class, 1);
 
         // Test webhook for recurring payments
 
         $wallet->transactions()->delete();
 
         $responseStack = $this->mockMollie();
         Bus::fake();
 
         $payment->refresh();
         $payment->status = PaymentProvider::STATUS_OPEN;
         $payment->save();
 
         $mollie_response = [
             "resource" => "payment",
             "id" => $payment->id,
             "status" => "paid",
             // Status is not enough, paidAt is used to distinguish the state
             "paidAt" => date('c'),
             "mode" => "test",
         ];
 
         // We'll trigger the webhook with payment id and use mocking for
         // a request to the Mollie payments API. We cannot force Mollie
         // to make the payment status change.
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $post = ['id' => $payment->id];
         $response = $this->post("api/webhooks/payment/mollie", $post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->fresh()->status);
         $this->assertEquals(2010, $wallet->fresh()->balance);
 
         $transaction = $wallet->transactions()
             ->where('type', Transaction::WALLET_CREDIT)->get()->last();
 
         $this->assertSame(2010, $transaction->amount);
         $this->assertSame(
             "Auto-payment transaction {$payment->id} using Mollie",
             $transaction->description
         );
 
         // Assert that email notification job has been dispatched
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 1);
         Bus::assertDispatched(\App\Jobs\PaymentEmail::class, function ($job) use ($payment) {
             $job_payment = $this->getObjectProperty($job, 'payment');
             return $job_payment->id === $payment->id;
         });
 
         Bus::fake();
 
         // Test for payment failure
         $payment->refresh();
         $payment->status = PaymentProvider::STATUS_OPEN;
         $payment->save();
 
         $wallet->setSetting('mollie_mandate_id', 'xxx');
         $wallet->setSetting('mandate_disabled', null);
 
         $mollie_response = [
             "resource" => "payment",
             "id" => $payment->id,
             "status" => "failed",
             "mode" => "test",
         ];
 
         $responseStack->append(new Response(200, [], json_encode($mollie_response)));
 
         $response = $this->post("api/webhooks/payment/mollie", $post);
         $response->assertStatus(200);
 
         $wallet->refresh();
 
         $this->assertSame(PaymentProvider::STATUS_FAILED, $payment->fresh()->status);
         $this->assertEquals(2010, $wallet->balance);
         $this->assertTrue(!empty($wallet->getSetting('mandate_disabled')));
 
         // Assert that email notification job has been dispatched
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 1);
         Bus::assertDispatched(\App\Jobs\PaymentEmail::class, function ($job) use ($payment) {
             $job_payment = $this->getObjectProperty($job, 'payment');
             return $job_payment->id === $payment->id;
         });
 
         $this->unmockMollie();
     }
 
     /**
      * Test refund/chargeback handling by the webhook
      *
      * @group mollie
      */
     public function testRefundAndChargeback(): void
     {
         Bus::fake();
 
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
         $wallet->transactions()->delete();
 
         $mollie = PaymentProvider::factory('mollie');
 
         // Create a paid payment
         $payment = Payment::create([
                 'id' => 'tr_123456',
                 'status' => PaymentProvider::STATUS_PAID,
                 'amount' => 123,
+                'currency_amount' => 123,
+                'currency' => 'CHF',
                 'type' => PaymentProvider::TYPE_ONEOFF,
                 'wallet_id' => $wallet->id,
                 'provider' => 'mollie',
                 'description' => 'test',
         ]);
 
         // Test handling a refund by the webhook
 
         $mollie_response1 = [
             "resource" => "payment",
             "id" => $payment->id,
             "status" => "paid",
             // Status is not enough, paidAt is used to distinguish the state
             "paidAt" => date('c'),
             "mode" => "test",
             "_links" => [
                 "refunds" => [
                    "href" => "https://api.mollie.com/v2/payments/{$payment->id}/refunds",
                    "type" => "application/hal+json"
                 ]
             ]
         ];
 
         $mollie_response2 = [
             "count" => 1,
             "_links" => [],
             "_embedded" => [
                 "refunds" => [
                     [
                         "resource" => "refund",
                         "id" => "re_123456",
                         "status" => \Mollie\Api\Types\RefundStatus::STATUS_REFUNDED,
                         "paymentId" => $payment->id,
                         "description" => "refund desc",
                         "amount" => [
                             "currency" => "CHF",
                             "value" => "1.01",
                         ],
                     ]
                 ]
             ]
         ];
 
         // We'll trigger the webhook with payment id and use mocking for
         // requests to the Mollie payments API.
         $responseStack = $this->mockMollie();
         $responseStack->append(new Response(200, [], json_encode($mollie_response1)));
         $responseStack->append(new Response(200, [], json_encode($mollie_response2)));
 
         $post = ['id' => $payment->id];
         $response = $this->post("api/webhooks/payment/mollie", $post);
         $response->assertStatus(200);
 
         $wallet->refresh();
 
         $this->assertEquals(-101, $wallet->balance);
 
         $transactions = $wallet->transactions()->where('type', Transaction::WALLET_REFUND)->get();
 
         $this->assertCount(1, $transactions);
         $this->assertSame(-101, $transactions[0]->amount);
         $this->assertSame(Transaction::WALLET_REFUND, $transactions[0]->type);
         $this->assertSame("refund desc", $transactions[0]->description);
 
         $payments = $wallet->payments()->where('id', 're_123456')->get();
 
         $this->assertCount(1, $payments);
         $this->assertSame(-101, $payments[0]->amount);
         $this->assertSame(PaymentProvider::STATUS_PAID, $payments[0]->status);
         $this->assertSame(PaymentProvider::TYPE_REFUND, $payments[0]->type);
         $this->assertSame("mollie", $payments[0]->provider);
         $this->assertSame("refund desc", $payments[0]->description);
 
         // Test handling a chargeback by the webhook
 
         $mollie_response1["_links"] = [
             "chargebacks" => [
                "href" => "https://api.mollie.com/v2/payments/{$payment->id}/chargebacks",
                "type" => "application/hal+json"
             ]
         ];
 
         $mollie_response2 = [
             "count" => 1,
             "_links" => [],
             "_embedded" => [
                 "chargebacks" => [
                     [
                         "resource" => "chargeback",
                         "id" => "chb_123456",
                         "paymentId" => $payment->id,
                         "amount" => [
                             "currency" => "CHF",
                             "value" => "0.15",
                         ],
                     ]
                 ]
             ]
         ];
 
         // We'll trigger the webhook with payment id and use mocking for
         // requests to the Mollie payments API.
         $responseStack = $this->mockMollie();
         $responseStack->append(new Response(200, [], json_encode($mollie_response1)));
         $responseStack->append(new Response(200, [], json_encode($mollie_response2)));
 
         $post = ['id' => $payment->id];
         $response = $this->post("api/webhooks/payment/mollie", $post);
         $response->assertStatus(200);
 
         $wallet->refresh();
 
         $this->assertEquals(-116, $wallet->balance);
 
         $transactions = $wallet->transactions()->where('type', Transaction::WALLET_CHARGEBACK)->get();
 
         $this->assertCount(1, $transactions);
         $this->assertSame(-15, $transactions[0]->amount);
         $this->assertSame(Transaction::WALLET_CHARGEBACK, $transactions[0]->type);
         $this->assertSame('', $transactions[0]->description);
 
         $payments = $wallet->payments()->where('id', 'chb_123456')->get();
 
         $this->assertCount(1, $payments);
         $this->assertSame(-15, $payments[0]->amount);
         $this->assertSame(PaymentProvider::STATUS_PAID, $payments[0]->status);
         $this->assertSame(PaymentProvider::TYPE_CHARGEBACK, $payments[0]->type);
         $this->assertSame("mollie", $payments[0]->provider);
         $this->assertSame('', $payments[0]->description);
 
         Bus::assertNotDispatched(\App\Jobs\PaymentEmail::class);
 
         $this->unmockMollie();
     }
 
     /**
      * Create Mollie's auto-payment mandate using our API and Chrome browser
      */
     protected function createMandate(Wallet $wallet, array $params)
     {
         // Use the API to create a first payment with a mandate
         $response = $this->actingAs($wallet->owner)->post("api/v4/payments/mandate", $params);
         $response->assertStatus(200);
         $json = $response->json();
 
         // There's no easy way to confirm a created mandate.
         // The only way seems to be to fire up Chrome on checkout page
         // and do actions with use of Dusk browser.
         $this->startBrowser()
             ->visit($json['redirectUrl'])
             ->click('input[value="paid"]')
             ->click('button.form__button');
 
         $this->stopBrowser();
     }
+
+
+    /**
+     * Test listing a pending payment
+     *
+     * @group mollie
+     */
+    public function testListingPayments(): void
+    {
+        Bus::fake();
+
+        $user = $this->getTestUser('john@kolab.org');
+
+        //Empty response
+        $response = $this->actingAs($user)->get("api/v4/payments/pending");
+        $json = $response->json();
+
+        $this->assertSame('success', $json['status']);
+        $this->assertSame(0, $json['count']);
+        $this->assertSame(1, $json['page']);
+        $this->assertSame(false, $json['hasMore']);
+        $this->assertCount(0, $json['list']);
+
+        $response = $this->actingAs($user)->get("api/v4/payments/has-pending");
+        $json = $response->json();
+        $this->assertSame(false, $json['hasPending']);
+
+        $wallet = $user->wallets()->first();
+
+        // Successful payment
+        $post = ['amount' => '12.34', 'currency' => 'CHF', 'methodId' => 'creditcard'];
+        $response = $this->actingAs($user)->post("api/v4/payments", $post);
+        $response->assertStatus(200);
+
+        //A response
+        $response = $this->actingAs($user)->get("api/v4/payments/pending");
+        $json = $response->json();
+
+        $this->assertSame('success', $json['status']);
+        $this->assertSame(1, $json['count']);
+        $this->assertSame(1, $json['page']);
+        $this->assertSame(false, $json['hasMore']);
+        $this->assertCount(1, $json['list']);
+        $this->assertSame(PaymentProvider::STATUS_OPEN, $json['list'][0]['status']);
+
+        $response = $this->actingAs($user)->get("api/v4/payments/has-pending");
+        $json = $response->json();
+        $this->assertSame(true, $json['hasPending']);
+
+        // Set the payment to paid
+        $payments = Payment::where('wallet_id', $wallet->id)->get();
+
+        $this->assertCount(1, $payments);
+        $payment = $payments[0];
+
+        $payment->status = PaymentProvider::STATUS_PAID;
+        $payment->save();
+
+        // They payment should be gone from the pending list now
+        $response = $this->actingAs($user)->get("api/v4/payments/pending");
+        $json = $response->json();
+        $this->assertSame('success', $json['status']);
+        $this->assertSame(0, $json['count']);
+        $this->assertCount(0, $json['list']);
+
+        $response = $this->actingAs($user)->get("api/v4/payments/has-pending");
+        $json = $response->json();
+        $this->assertSame(false, $json['hasPending']);
+    }
+
+    /**
+     * Test listing payment methods
+     *
+     * @group mollie
+     */
+    public function testListingPaymentMethods(): void
+    {
+        Bus::fake();
+
+        $user = $this->getTestUser('john@kolab.org');
+
+        $response = $this->actingAs($user)->get('api/v4/payments/methods?type=' . PaymentProvider::TYPE_ONEOFF);
+        $response->assertStatus(200);
+        $json = $response->json();
+
+        $this->assertCount(2, $json);
+        $this->assertSame('creditcard', $json[0]['id']);
+        $this->assertSame('paypal', $json[1]['id']);
+
+        $response = $this->actingAs($user)->get('api/v4/payments/methods?type=' . PaymentProvider::TYPE_RECURRING);
+        $response->assertStatus(200);
+        $json = $response->json();
+
+        $this->assertCount(1, $json);
+        $this->assertSame('creditcard', $json[0]['id']);
+    }
 }
diff --git a/src/tests/Feature/Controller/PaymentsStripeTest.php b/src/tests/Feature/Controller/PaymentsStripeTest.php
index d1a56de1..e9f70c5d 100644
--- a/src/tests/Feature/Controller/PaymentsStripeTest.php
+++ b/src/tests/Feature/Controller/PaymentsStripeTest.php
@@ -1,709 +1,743 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\Http\Controllers\API\V4\PaymentsController;
 use App\Payment;
 use App\Providers\PaymentProvider;
 use App\Transaction;
 use App\Wallet;
 use App\WalletSetting;
 use GuzzleHttp\Psr7\Response;
 use Illuminate\Support\Facades\Bus;
 use Tests\TestCase;
 use Tests\StripeMocksTrait;
 
 class PaymentsStripeTest extends TestCase
 {
     use StripeMocksTrait;
 
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         // All tests in this file use Stripe
         \config(['services.payment_provider' => 'stripe']);
 
         $john = $this->getTestUser('john@kolab.org');
         $wallet = $john->wallets()->first();
         Payment::where('wallet_id', $wallet->id)->delete();
         Wallet::where('id', $wallet->id)->update(['balance' => 0]);
         WalletSetting::where('wallet_id', $wallet->id)->delete();
         Transaction::where('object_id', $wallet->id)
             ->where('type', Transaction::WALLET_CREDIT)->delete();
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $wallet = $john->wallets()->first();
         Payment::where('wallet_id', $wallet->id)->delete();
         Wallet::where('id', $wallet->id)->update(['balance' => 0]);
         WalletSetting::where('wallet_id', $wallet->id)->delete();
         Transaction::where('object_id', $wallet->id)
             ->where('type', Transaction::WALLET_CREDIT)->delete();
 
         parent::tearDown();
     }
 
     /**
      * Test creating/updating/deleting an outo-payment mandate
      *
      * @group stripe
      */
     public function testMandates(): void
     {
         Bus::fake();
 
         // Unauth access not allowed
         $response = $this->get("api/v4/payments/mandate");
         $response->assertStatus(401);
         $response = $this->post("api/v4/payments/mandate", []);
         $response->assertStatus(401);
         $response = $this->put("api/v4/payments/mandate", []);
         $response->assertStatus(401);
         $response = $this->delete("api/v4/payments/mandate");
         $response->assertStatus(401);
 
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
 
         // Test creating a mandate (invalid input)
         $post = [];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json['errors']);
         $this->assertSame('The amount field is required.', $json['errors']['amount'][0]);
         $this->assertSame('The balance field is required.', $json['errors']['balance'][0]);
 
         // Test creating a mandate (invalid input)
         $post = ['amount' => 100, 'balance' => 'a'];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame('The balance must be a number.', $json['errors']['balance'][0]);
 
         // Test creating a mandate (invalid input)
         $post = ['amount' => -100, 'balance' => 0];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $min = intval(PaymentProvider::MIN_AMOUNT / 100) . ' CHF';
         $this->assertSame("Minimum amount for a single payment is {$min}.", $json['errors']['amount']);
 
         // Test creating a mandate (negative balance, amount too small)
         Wallet::where('id', $wallet->id)->update(['balance' => -2000]);
         $post = ['amount' => PaymentProvider::MIN_AMOUNT / 100, 'balance' => 0];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame("The specified amount does not cover the balance on the account.", $json['errors']['amount']);
 
         // Test creating a mandate (valid input)
         $post = ['amount' => 20.10, 'balance' => 0];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertRegExp('|^cs_test_|', $json['id']);
 
         // Assert the proper payment amount has been used
         // Stripe in 'setup' mode does not allow to set the amount
         $payment = Payment::where('wallet_id', $wallet->id)->first();
         $this->assertSame(0, $payment->amount);
-        $this->assertSame("Kolab Now Auto-Payment Setup", $payment->description);
+        $this->assertSame(\config('app.name') . " Auto-Payment Setup", $payment->description);
         $this->assertSame(PaymentProvider::TYPE_MANDATE, $payment->type);
 
         // Test fetching the mandate information
         $response = $this->actingAs($user)->get("api/v4/payments/mandate");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals(20.10, $json['amount']);
         $this->assertEquals(0, $json['balance']);
         $this->assertSame(false, $json['isDisabled']);
 
         // We would have to invoke a browser to accept the "first payment" to make
         // the mandate validated/completed. Instead, we'll mock the mandate object.
         $setupIntent = '{
             "id": "AAA",
             "object": "setup_intent",
             "created": 123456789,
             "payment_method": "pm_YYY",
             "status": "succeeded",
             "usage": "off_session",
             "customer": null
         }';
 
         $paymentMethod = '{
             "id": "pm_YYY",
             "object": "payment_method",
             "card": {
                 "brand": "visa",
                 "country": "US",
                 "last4": "4242"
             },
             "created": 123456789,
             "type": "card"
         }';
 
         $client = $this->mockStripe();
         $client->addResponse($setupIntent);
         $client->addResponse($paymentMethod);
 
         // As we do not use checkout page, we do not receive a webworker request
         // I.e. we have to fake the mandate id
         $wallet = $user->wallets()->first();
         $wallet->setSetting('stripe_mandate_id', 'AAA');
         $wallet->setSetting('mandate_disabled', 1);
 
         $response = $this->actingAs($user)->get("api/v4/payments/mandate");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals(20.10, $json['amount']);
         $this->assertEquals(0, $json['balance']);
         $this->assertEquals('Visa (**** **** **** 4242)', $json['method']);
         $this->assertSame(false, $json['isPending']);
         $this->assertSame(true, $json['isValid']);
         $this->assertSame(true, $json['isDisabled']);
 
         // Test updating mandate details (invalid input)
         $wallet->setSetting('mandate_disabled', null);
         $wallet->balance = 1000;
         $wallet->save();
         $user->refresh();
         $post = [];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json['errors']);
         $this->assertSame('The amount field is required.', $json['errors']['amount'][0]);
         $this->assertSame('The balance field is required.', $json['errors']['balance'][0]);
 
         $post = ['amount' => -100, 'balance' => 0];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame("Minimum amount for a single payment is {$min}.", $json['errors']['amount']);
 
         // Test updating a mandate (valid input)
         $client->addResponse($setupIntent);
         $client->addResponse($paymentMethod);
 
         $post = ['amount' => 30.10, 'balance' => 10];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('The auto-payment has been updated.', $json['message']);
         $this->assertEquals(30.10, $wallet->getSetting('mandate_amount'));
         $this->assertEquals(10, $wallet->getSetting('mandate_balance'));
         $this->assertSame('AAA', $json['id']);
         $this->assertFalse($json['isDisabled']);
 
         // Test updating a disabled mandate (invalid input)
         $wallet->setSetting('mandate_disabled', 1);
         $wallet->balance = -2000;
         $wallet->save();
         $user->refresh(); // required so the controller sees the wallet update from above
 
         $post = ['amount' => 15.10, 'balance' => 1];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame('The specified amount does not cover the balance on the account.', $json['errors']['amount']);
 
         // Test updating a disabled mandate (valid input)
         $client->addResponse($setupIntent);
         $client->addResponse($paymentMethod);
 
         $post = ['amount' => 30, 'balance' => 1];
         $response = $this->actingAs($user)->put("api/v4/payments/mandate", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('The auto-payment has been updated.', $json['message']);
         $this->assertSame('AAA', $json['id']);
         $this->assertFalse($json['isDisabled']);
 
         Bus::assertDispatchedTimes(\App\Jobs\WalletCharge::class, 1);
         Bus::assertDispatched(\App\Jobs\WalletCharge::class, function ($job) use ($wallet) {
             $job_wallet = $this->getObjectProperty($job, 'wallet');
             return $job_wallet->id === $wallet->id;
         });
 
 
         $this->unmockStripe();
 
         // TODO: Delete mandate
     }
 
     /**
      * Test creating a payment and receiving a status via webhook
      *
      * @group stripe
      */
     public function testStoreAndWebhook(): void
     {
         Bus::fake();
 
         // Unauth access not allowed
         $response = $this->post("api/v4/payments", []);
         $response->assertStatus(401);
 
         $user = $this->getTestUser('john@kolab.org');
 
         $post = ['amount' => -1];
         $response = $this->actingAs($user)->post("api/v4/payments", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $min = intval(PaymentProvider::MIN_AMOUNT / 100) . ' CHF';
         $this->assertSame("Minimum amount for a single payment is {$min}.", $json['errors']['amount']);
 
-        $post = ['amount' => '12.34'];
+
+        // Invalid currency
+        $post = ['amount' => '12.34', 'currency' => 'FOO', 'methodId' => 'creditcard'];
+        $response = $this->actingAs($user)->post("api/v4/payments", $post);
+        $response->assertStatus(500);
+
+        // Successful payment
+        $post = ['amount' => '12.34', 'currency' => 'CHF', 'methodId' => 'creditcard'];
         $response = $this->actingAs($user)->post("api/v4/payments", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertRegExp('|^cs_test_|', $json['id']);
 
         $wallet = $user->wallets()->first();
         $payments = Payment::where('wallet_id', $wallet->id)->get();
 
         $this->assertCount(1, $payments);
         $payment = $payments[0];
         $this->assertSame(1234, $payment->amount);
         $this->assertSame(\config('app.name') . ' Payment', $payment->description);
         $this->assertSame('open', $payment->status);
         $this->assertEquals(0, $wallet->balance);
 
         // Test the webhook
 
         $post = [
             'id' => "evt_1GlZ814fj3SIEU8wtxMZ4Nsa",
             'object' => "event",
             'api_version' => "2020-03-02",
             'created' => 1590147209,
             'data' => [
                 'object' => [
                     'id' => $payment->id,
                     'object' => "payment_intent",
                     'amount' => 1234,
                     'amount_capturable' => 0,
                     'amount_received' => 1234,
                     'capture_method' => "automatic",
                     'client_secret' => "pi_1GlZ7w4fj3SIEU8w1RlBpN4l_secret_UYRNDTUUU7nkYHpOLZMb3uf48",
                     'confirmation_method' => "automatic",
                     'created' => 1590147204,
                     'currency' => "chf",
                     'customer' => "cus_HKDZ53OsKdlM83",
                     'last_payment_error' => null,
                     'livemode' => false,
                     'metadata' => [],
                     'receipt_email' => "payment-test@kolabnow.com",
                     'status' => "succeeded"
                 ]
             ],
             'type' => "payment_intent.succeeded"
         ];
 
         // Test payment succeeded event
         $response = $this->webhookRequest($post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->fresh()->status);
         $this->assertEquals(1234, $wallet->fresh()->balance);
 
         $transaction = $wallet->transactions()
             ->where('type', Transaction::WALLET_CREDIT)->get()->last();
 
         $this->assertSame(1234, $transaction->amount);
         $this->assertSame(
             "Payment transaction {$payment->id} using Stripe",
             $transaction->description
         );
 
         // Assert that email notification job wasn't dispatched,
         // it is expected only for recurring payments
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 0);
 
         // Test that balance didn't change if the same event is posted
         $response = $this->webhookRequest($post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->fresh()->status);
         $this->assertEquals(1234, $wallet->fresh()->balance);
 
         // Test for payment failure ('failed' status)
         $payment->refresh();
         $payment->status = PaymentProvider::STATUS_OPEN;
         $payment->save();
 
         $post['type'] = "payment_intent.payment_failed";
         $post['data']['object']['status'] = 'failed';
 
         $response = $this->webhookRequest($post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_FAILED, $payment->fresh()->status);
         $this->assertEquals(1234, $wallet->fresh()->balance);
 
         // Assert that email notification job wasn't dispatched,
         // it is expected only for recurring payments
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 0);
 
         // Test for payment failure ('canceled' status)
         $payment->refresh();
         $payment->status = PaymentProvider::STATUS_OPEN;
         $payment->save();
 
         $post['type'] = "payment_intent.canceled";
         $post['data']['object']['status'] = 'canceled';
 
         $response = $this->webhookRequest($post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_CANCELED, $payment->fresh()->status);
         $this->assertEquals(1234, $wallet->fresh()->balance);
 
         // Assert that email notification job wasn't dispatched,
         // it is expected only for recurring payments
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 0);
     }
 
     /**
      * Test receiving webhook request for setup intent
      *
      * @group stripe
      */
     public function testCreateMandateAndWebhook(): void
     {
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
         Wallet::where('id', $wallet->id)->update(['balance' => -1000]);
 
         // Test creating a mandate (valid input)
         $post = ['amount' => 20.10, 'balance' => 0];
         $response = $this->actingAs($user)->post("api/v4/payments/mandate", $post);
         $response->assertStatus(200);
 
         $payment = $wallet->payments()->first();
 
         $this->assertSame(PaymentProvider::STATUS_OPEN, $payment->status);
         $this->assertSame(PaymentProvider::TYPE_MANDATE, $payment->type);
         $this->assertSame(0, $payment->amount);
 
         $post = [
             'id' => "evt_1GlZ814fj3SIEU8wtxMZ4Nsa",
             'object' => "event",
             'api_version' => "2020-03-02",
             'created' => 1590147209,
             'data' => [
                 'object' => [
                     'id' => $payment->id,
                     'object' => "setup_intent",
                     'client_secret' => "pi_1GlZ7w4fj3SIEU8w1RlBpN4l_secret_UYRNDTUUU7nkYHpOLZMb3uf48",
                     'created' => 1590147204,
                     'customer' => "cus_HKDZ53OsKdlM83",
                     'last_setup_error' => null,
                     'metadata' => [],
                     'status' => "succeeded"
                 ]
             ],
             'type' => "setup_intent.succeeded"
         ];
 
         Bus::fake();
 
         // Test payment succeeded event
         $response = $this->webhookRequest($post);
         $response->assertStatus(200);
 
         $payment->refresh();
 
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->status);
         $this->assertSame($payment->id, $wallet->fresh()->getSetting('stripe_mandate_id'));
 
         // Expect a WalletCharge job if the balance is negative
         Bus::assertDispatchedTimes(\App\Jobs\WalletCharge::class, 1);
         Bus::assertDispatched(\App\Jobs\WalletCharge::class, function ($job) use ($wallet) {
             $job_wallet = TestCase::getObjectProperty($job, 'wallet');
             return $job_wallet->id === $wallet->id;
         });
 
         // TODO: test other setup_intent.* events
     }
 
     /**
      * Test automatic payment charges
      *
      * @group stripe
      */
     public function testTopUpAndWebhook(): void
     {
         Bus::fake();
 
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
 
         // Stripe API does not allow us to create a mandate easily
         // That's why we we'll mock API responses
         // Create a fake mandate
         $wallet->setSettings([
             'mandate_amount' => 20.10,
             'mandate_balance' => 10,
             'stripe_mandate_id' => 'AAA',
         ]);
 
         $setupIntent = json_encode([
                 "id" => "AAA",
                 "object" => "setup_intent",
                 "created" => 123456789,
                 "payment_method" => "pm_YYY",
                 "status" => "succeeded",
                 "usage" => "off_session",
                 "customer" => null
         ]);
 
         $paymentMethod = json_encode([
                 "id" => "pm_YYY",
                 "object" => "payment_method",
                 "card" => [
                     "brand" => "visa",
                     "country" => "US",
                     "last4" => "4242"
                 ],
                 "created" => 123456789,
                 "type" => "card"
         ]);
 
         $paymentIntent = json_encode([
                 "id" => "pi_XX",
                 "object" => "payment_intent",
                 "created" => 123456789,
                 "amount" => 2010,
                 "currency" => "chf",
                 "description" => "Kolab Recurring Payment"
         ]);
 
         $client = $this->mockStripe();
         $client->addResponse($setupIntent);
         $client->addResponse($paymentMethod);
         $client->addResponse($setupIntent);
         $client->addResponse($paymentIntent);
         $client->addResponse($setupIntent);
         $client->addResponse($paymentMethod);
 
         // Expect a recurring payment as we have a valid mandate at this point
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertTrue($result);
 
         // Check that the payments table contains a new record with proper amount
         // There should be two records, one for the first payment and another for
         // the recurring payment
         $this->assertCount(1, $wallet->payments()->get());
         $payment = $wallet->payments()->first();
         $this->assertSame(2010, $payment->amount);
         $this->assertSame(\config('app.name') . " Recurring Payment", $payment->description);
         $this->assertSame("pi_XX", $payment->id);
 
         // Expect no payment if the mandate is disabled
         $wallet->setSetting('mandate_disabled', 1);
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertFalse($result);
         $this->assertCount(1, $wallet->payments()->get());
 
         // Expect no payment if balance is ok
         $wallet->setSetting('mandate_disabled', null);
         $wallet->balance = 1000;
         $wallet->save();
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertFalse($result);
         $this->assertCount(1, $wallet->payments()->get());
 
         // Expect no payment if the top-up amount is not enough
         $wallet->setSetting('mandate_disabled', null);
         $wallet->balance = -2050;
         $wallet->save();
 
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertFalse($result);
         $this->assertCount(1, $wallet->payments()->get());
 
         Bus::assertDispatchedTimes(\App\Jobs\PaymentMandateDisabledEmail::class, 1);
         Bus::assertDispatched(\App\Jobs\PaymentMandateDisabledEmail::class, function ($job) use ($wallet) {
             $job_wallet = $this->getObjectProperty($job, 'wallet');
             return $job_wallet->id === $wallet->id;
         });
 
         // Expect no payment if there's no mandate
         $wallet->setSetting('mollie_mandate_id', null);
         $wallet->balance = 0;
         $wallet->save();
         $result = PaymentsController::topUpWallet($wallet);
         $this->assertFalse($result);
         $this->assertCount(1, $wallet->payments()->get());
 
         Bus::assertDispatchedTimes(\App\Jobs\PaymentMandateDisabledEmail::class, 1);
 
         $this->unmockStripe();
 
         // Test webhook
 
         $post = [
             'id' => "evt_1GlZ814fj3SIEU8wtxMZ4Nsa",
             'object' => "event",
             'api_version' => "2020-03-02",
             'created' => 1590147209,
             'data' => [
                 'object' => [
                     'id' => $payment->id,
                     'object' => "payment_intent",
                     'amount' => 2010,
                     'capture_method' => "automatic",
                     'created' => 1590147204,
                     'currency' => "chf",
                     'customer' => "cus_HKDZ53OsKdlM83",
                     'last_payment_error' => null,
                     'metadata' => [],
                     'receipt_email' => "payment-test@kolabnow.com",
                     'status' => "succeeded"
                 ]
             ],
             'type' => "payment_intent.succeeded"
         ];
 
         // Test payment succeeded event
         $response = $this->webhookRequest($post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_PAID, $payment->fresh()->status);
         $this->assertEquals(2010, $wallet->fresh()->balance);
         $transaction = $wallet->transactions()
             ->where('type', Transaction::WALLET_CREDIT)->get()->last();
 
         $this->assertSame(2010, $transaction->amount);
         $this->assertSame(
             "Auto-payment transaction {$payment->id} using Stripe",
             $transaction->description
         );
 
         // Assert that email notification job has been dispatched
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 1);
         Bus::assertDispatched(\App\Jobs\PaymentEmail::class, function ($job) use ($payment) {
             $job_payment = $this->getObjectProperty($job, 'payment');
             return $job_payment->id === $payment->id;
         });
 
         Bus::fake();
 
         // Test for payment failure ('failed' status)
         $payment->refresh();
         $payment->status = PaymentProvider::STATUS_OPEN;
         $payment->save();
 
         $wallet->setSetting('mandate_disabled', null);
 
         $post['type'] = "payment_intent.payment_failed";
         $post['data']['object']['status'] = 'failed';
 
         $response = $this->webhookRequest($post);
         $response->assertStatus(200);
 
         $wallet->refresh();
 
         $this->assertSame(PaymentProvider::STATUS_FAILED, $payment->fresh()->status);
         $this->assertEquals(2010, $wallet->balance);
         $this->assertTrue(!empty($wallet->getSetting('mandate_disabled')));
 
         // Assert that email notification job has been dispatched
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 1);
         Bus::assertDispatched(\App\Jobs\PaymentEmail::class, function ($job) use ($payment) {
             $job_payment = $this->getObjectProperty($job, 'payment');
             return $job_payment->id === $payment->id;
         });
 
         Bus::fake();
 
         // Test for payment failure ('canceled' status)
         $payment->refresh();
         $payment->status = PaymentProvider::STATUS_OPEN;
         $payment->save();
 
         $post['type'] = "payment_intent.canceled";
         $post['data']['object']['status'] = 'canceled';
 
         $response = $this->webhookRequest($post);
         $response->assertStatus(200);
 
         $this->assertSame(PaymentProvider::STATUS_CANCELED, $payment->fresh()->status);
         $this->assertEquals(2010, $wallet->fresh()->balance);
 
         // Assert that email notification job wasn't dispatched,
         // it is expected only for recurring payments
         Bus::assertDispatchedTimes(\App\Jobs\PaymentEmail::class, 0);
     }
 
     /**
      * Generate Stripe-Signature header for a webhook payload
      */
     protected function webhookRequest($post)
     {
         $secret = \config('services.stripe.webhook_secret');
         $ts = time();
 
         $payload = "$ts." . json_encode($post);
         $sig = sprintf('t=%d,v1=%s', $ts, \hash_hmac('sha256', $payload, $secret));
 
         return $this->withHeaders(['Stripe-Signature' => $sig])
             ->json('POST', "api/webhooks/payment/stripe", $post);
     }
+
+    /**
+     * Test listing payment methods
+     *
+     * @group stripe
+     */
+    public function testListingPaymentMethods(): void
+    {
+        Bus::fake();
+
+        $user = $this->getTestUser('john@kolab.org');
+
+        $response = $this->actingAs($user)->get('api/v4/payments/methods?type=' . PaymentProvider::TYPE_ONEOFF);
+        $response->assertStatus(200);
+        $json = $response->json();
+
+        $this->assertCount(2, $json);
+        $this->assertSame('creditcard', $json[0]['id']);
+        $this->assertSame('paypal', $json[1]['id']);
+
+        $response = $this->actingAs($user)->get('api/v4/payments/methods?type=' . PaymentProvider::TYPE_RECURRING);
+        $response->assertStatus(200);
+        $json = $response->json();
+
+        $this->assertCount(1, $json);
+        $this->assertSame('creditcard', $json[0]['id']);
+    }
 }
diff --git a/src/tests/Feature/Jobs/PaymentEmailTest.php b/src/tests/Feature/Jobs/PaymentEmailTest.php
index 9ef6cfca..b2813a87 100644
--- a/src/tests/Feature/Jobs/PaymentEmailTest.php
+++ b/src/tests/Feature/Jobs/PaymentEmailTest.php
@@ -1,120 +1,122 @@
 <?php
 
 namespace Tests\Feature\Jobs;
 
 use App\Jobs\PaymentEmail;
 use App\Mail\PaymentFailure;
 use App\Mail\PaymentSuccess;
 use App\Payment;
 use App\Providers\PaymentProvider;
 use Illuminate\Support\Facades\Mail;
 use Tests\TestCase;
 
 class PaymentEmailTest extends TestCase
 {
     /**
      * {@inheritDoc}
      *
      * @return void
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('PaymentEmail@UserAccount.com');
     }
 
     /**
      * {@inheritDoc}
      *
      * @return void
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('PaymentEmail@UserAccount.com');
 
         parent::tearDown();
     }
 
     /**
      * Test job handle
      *
      * @return void
      */
     public function testHandle()
     {
         $user = $this->getTestUser('PaymentEmail@UserAccount.com');
         $user->setSetting('external_email', 'ext@email.tld');
         $wallet = $user->wallets()->first();
 
         $payment = new Payment();
         $payment->id = 'test-payment';
         $payment->wallet_id = $wallet->id;
         $payment->amount = 100;
+        $payment->currency_amount = 100;
+        $payment->currency = 'CHF';
         $payment->status = PaymentProvider::STATUS_PAID;
         $payment->description = 'test';
         $payment->provider = 'stripe';
         $payment->type = PaymentProvider::TYPE_ONEOFF;
         $payment->save();
 
         Mail::fake();
 
         // Assert that no jobs were pushed...
         Mail::assertNothingSent();
 
         $job = new PaymentEmail($payment);
         $job->handle();
 
         // Assert the email sending job was pushed once
         Mail::assertSent(PaymentSuccess::class, 1);
 
         // Assert the mail was sent to the user's email
         Mail::assertSent(PaymentSuccess::class, function ($mail) {
             return $mail->hasTo('ext@email.tld') && !$mail->hasCc('ext@email.tld');
         });
 
         $payment->status = PaymentProvider::STATUS_FAILED;
         $payment->save();
 
         $job = new PaymentEmail($payment);
         $job->handle();
 
         // Assert the email sending job was pushed once
         Mail::assertSent(PaymentFailure::class, 1);
 
         // Assert the mail was sent to the user's email
         Mail::assertSent(PaymentFailure::class, function ($mail) {
             return $mail->hasTo('ext@email.tld') && !$mail->hasCc('ext@email.tld');
         });
 
         $payment->status = PaymentProvider::STATUS_EXPIRED;
         $payment->save();
 
         $job = new PaymentEmail($payment);
         $job->handle();
 
         // Assert the email sending job was pushed twice
         Mail::assertSent(PaymentFailure::class, 2);
 
         // None of statuses below should trigger an email
         Mail::fake();
 
         $states = [
             PaymentProvider::STATUS_OPEN,
             PaymentProvider::STATUS_CANCELED,
             PaymentProvider::STATUS_PENDING,
             PaymentProvider::STATUS_AUTHORIZED,
         ];
 
         foreach ($states as $state) {
             $payment->status = $state;
             $payment->save();
 
             $job = new PaymentEmail($payment);
             $job->handle();
         }
 
         // Assert that no mailables were sent...
         Mail::assertNothingSent();
     }
 }