diff --git a/src/app/Http/Controllers/API/V4/Admin/WalletsController.php b/src/app/Http/Controllers/API/V4/Admin/WalletsController.php
index a9843bc6..82bbcf3d 100644
--- a/src/app/Http/Controllers/API/V4/Admin/WalletsController.php
+++ b/src/app/Http/Controllers/API/V4/Admin/WalletsController.php
@@ -1,146 +1,146 @@
 <?php
 
 namespace App\Http\Controllers\API\V4\Admin;
 
 use App\Discount;
 use App\Http\Controllers\API\V4\PaymentsController;
 use App\Providers\PaymentProvider;
 use App\Transaction;
 use App\Wallet;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Validator;
 
 class WalletsController extends \App\Http\Controllers\API\V4\WalletsController
 {
     /**
      * Return data of the specified wallet.
      *
      * @param string $id A wallet identifier
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function show($id)
     {
         $wallet = Wallet::find($id);
 
         if (empty($wallet) || !$this->checkTenant($wallet->owner)) {
             return $this->errorResponse(404);
         }
 
         $result = $wallet->toArray();
 
         $result['discount'] = 0;
         $result['discount_description'] = '';
 
         if ($wallet->discount) {
             $result['discount'] = $wallet->discount->discount;
             $result['discount_description'] = $wallet->discount->description;
         }
 
         $result['mandate'] = PaymentsController::walletMandate($wallet);
 
         $provider = PaymentProvider::factory($wallet);
 
         $result['provider'] = $provider->name();
         $result['providerLink'] = $provider->customerLink($wallet);
         $result['notice'] = $this->getWalletNotice($wallet); // for resellers
 
         return response()->json($result);
     }
 
     /**
      * Award/penalize a wallet.
      *
      * @param \Illuminate\Http\Request $request The API request.
      * @param string                   $id      Wallet identifier
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function oneOff(Request $request, $id)
     {
         $wallet = Wallet::find($id);
         $user = $this->guard()->user();
 
         if (empty($wallet) || !$this->checkTenant($wallet->owner)) {
             return $this->errorResponse(404);
         }
 
         // Check required fields
         $v = Validator::make(
             $request->all(),
             [
                 'amount' => 'required|numeric',
                 'description' => 'required|string|max:1024',
             ]
         );
 
         if ($v->fails()) {
             return response()->json(['status' => 'error', 'errors' => $v->errors()], 422);
         }
 
-        $amount = (int) ($request->amount * 100);
+        $amount = (int) round($request->amount * 100);
         $method = $amount > 0 ? 'award' : 'penalty';
 
         DB::beginTransaction();
 
         $wallet->{$method}(abs($amount), $request->description);
 
         if ($user->role == 'reseller') {
             if ($user->tenant && ($tenant_wallet = $user->tenant->wallet())) {
                 $desc = ($amount > 0 ? 'Awarded' : 'Penalized') . " user {$wallet->owner->email}";
                 $tenant_method = $amount > 0 ? 'debit' : 'credit';
                 $tenant_wallet->{$tenant_method}(abs($amount), $desc);
             }
         }
 
         DB::commit();
 
         $response = [
             'status' => 'success',
             'message' => self::trans("app.wallet-{$method}-success"),
             'balance' => $wallet->balance
         ];
 
         return response()->json($response);
     }
 
     /**
      * Update wallet data.
      *
      * @param \Illuminate\Http\Request $request The API request.
      * @param string                   $id      Wallet identifier
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function update(Request $request, $id)
     {
         $wallet = Wallet::find($id);
 
         if (empty($wallet) || !$this->checkTenant($wallet->owner)) {
             return $this->errorResponse(404);
         }
 
         if (array_key_exists('discount', $request->input())) {
             if (empty($request->discount)) {
                 $wallet->discount()->dissociate();
                 $wallet->save();
             } elseif ($discount = Discount::withObjectTenantContext($wallet->owner)->find($request->discount)) {
                 $wallet->discount()->associate($discount);
                 $wallet->save();
             }
         }
 
         $response = $wallet->toArray();
 
         if ($wallet->discount) {
             $response['discount'] = $wallet->discount->discount;
             $response['discount_description'] = $wallet->discount->description;
         }
 
         $response['status'] = 'success';
         $response['message'] = self::trans('app.wallet-update-success');
 
         return response()->json($response);
     }
 }
diff --git a/src/app/Http/Controllers/API/V4/PaymentsController.php b/src/app/Http/Controllers/API/V4/PaymentsController.php
index c6318673..dc8b3420 100644
--- a/src/app/Http/Controllers/API/V4/PaymentsController.php
+++ b/src/app/Http/Controllers/API/V4/PaymentsController.php
@@ -1,597 +1,597 @@
 <?php
 
 namespace App\Http\Controllers\API\V4;
 
 use App\Http\Controllers\Controller;
 use App\Payment;
 use App\Providers\PaymentProvider;
 use App\Tenant;
 use App\Wallet;
 use Illuminate\Http\Request;
 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 = $this->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)
     {
         $user = $this->guard()->user();
 
         // TODO: Wallet selection
         $wallet = $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' => $wallet->currency,
 
             'description' => Tenant::getConfig($user->tenant_id, 'app.name')
                 . ' ' . self::trans('app.mandate-description-suffix'),
 
             'methodId' => $request->methodId ?: PaymentProvider::METHOD_CREDITCARD,
         ];
 
         // 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);
+        if ($wallet->balance < round($request->balance * 100)) {
+            $mandate['amount'] = (int) round($request->amount * 100);
 
             self::addTax($wallet, $mandate);
         }
 
         $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 = $this->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' => self::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)
     {
         $user = $this->guard()->user();
 
         // TODO: Wallet selection
         $wallet = $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)) {
+        if ($wallet->balance < round($request->balance * 100)) {
             \App\Jobs\WalletCharge::dispatch($wallet);
         }
 
         $result = self::walletMandate($wallet);
         $result['status'] = 'success';
         $result['message'] = self::trans('app.mandate-update-success');
 
         return response()->json($result);
     }
 
     /**
      * Reset the auto-payment mandate, create a new payment for it.
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function mandateReset(Request $request)
     {
         $user = $this->guard()->user();
 
         // TODO: Wallet selection
         $wallet = $user->wallets()->first();
 
         $mandate = [
             'currency' => $wallet->currency,
 
             'description' => Tenant::getConfig($user->tenant_id, 'app.name')
                 . ' ' . self::trans('app.mandate-description-suffix'),
 
             'methodId' => $request->methodId ?: PaymentProvider::METHOD_CREDITCARD,
             'redirectUrl' => \App\Utils::serviceUrl('/payment/status', $user->tenant_id),
         ];
 
         $provider = PaymentProvider::factory($wallet);
 
         $result = $provider->createMandate($wallet, $mandate);
 
         $result['status'] = '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);
+        $amount = (int) round($request->amount * 100);
 
         // Validate the minimum value
         // It has to be at least minimum payment amount and must cover current debt,
         // and must be more than a yearly/monthly payment (according to the plan)
         $min = $wallet->getMinMandateAmount();
         $label = 'minamount';
 
         if ($wallet->balance < 0 && $wallet->balance < $min * -1) {
             $min = $wallet->balance * -1;
             $label = 'minamountdebt';
         }
 
         if ($amount < $min) {
             return ['amount' => self::trans("validation.{$label}", ['amount' => $wallet->money($min)])];
         }
 
         return null;
     }
 
     /**
      * Get status of the last payment.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function paymentStatus()
     {
         $user = $this->guard()->user();
         $wallet = $user->wallets()->first();
 
         $payment = $wallet->payments()->orderBy('created_at', 'desc')->first();
 
         if (empty($payment)) {
             return $this->errorResponse(404);
         }
 
         $done = [Payment::STATUS_PAID, Payment::STATUS_CANCELED, Payment::STATUS_FAILED, Payment::STATUS_EXPIRED];
 
         if (in_array($payment->status, $done)) {
             $label = "app.payment-status-{$payment->status}";
         } else {
             $label = "app.payment-status-checking";
         }
 
         return response()->json([
                 'id' => $payment->id,
                 'status' => $payment->status,
                 'type' => $payment->type,
                 'statusMessage' => self::trans($label),
                 'description' => $payment->description,
         ]);
     }
 
     /**
      * Create a new payment.
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function store(Request $request)
     {
         $user = $this->guard()->user();
 
         // TODO: Wallet selection
         $wallet = $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);
+        $amount = (int) round($request->amount * 100);
 
         // Validate the minimum value
         if ($amount < Payment::MIN_AMOUNT) {
             $min = $wallet->money(Payment::MIN_AMOUNT);
             $errors = ['amount' => self::trans('validation.minamount', ['amount' => $min])];
             return response()->json(['status' => 'error', 'errors' => $errors], 422);
         }
 
         $currency = $request->currency;
 
         $request = [
             'type' => Payment::TYPE_ONEOFF,
             'currency' => $currency,
             'amount' => $amount,
             'methodId' => $request->methodId ?: PaymentProvider::METHOD_CREDITCARD,
             'description' => Tenant::getConfig($user->tenant_id, 'app.name') . ' Payment',
         ];
 
         self::addTax($wallet, $request);
 
         $provider = PaymentProvider::factory($wallet, $currency);
 
         $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)
     // {
     //     $user = $this->guard()->user();
 
     //     // TODO: Wallet selection
     //     $wallet = $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
     {
         $settings = $wallet->getSettings(['mandate_disabled', 'mandate_balance', 'mandate_amount']);
 
         \Log::debug("Requested top-up for wallet {$wallet->id}");
 
         if (!empty($settings['mandate_disabled'])) {
             \Log::debug("Top-up for wallet {$wallet->id}: mandate disabled");
             return false;
         }
 
-        $min_balance = (int) (floatval($settings['mandate_balance']) * 100);
-        $amount = (int) (floatval($settings['mandate_amount']) * 100);
+        $min_balance = (int) round(floatval($settings['mandate_balance']) * 100);
+        $amount = (int) round(floatval($settings['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'])) {
             \Log::debug("Top-up for wallet {$wallet->id}: mandate invalid");
             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' => Payment::TYPE_RECURRING,
             'currency' => $wallet->currency,
             'amount' => $amount,
             'methodId' => PaymentProvider::METHOD_CREDITCARD,
             'description' => Tenant::getConfig($wallet->owner->tenant_id, 'app.name') . ' Recurring Payment',
         ];
 
         self::addTax($wallet, $request);
 
         $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);
         $settings = $wallet->getSettings(['mandate_disabled', 'mandate_balance', 'mandate_amount']);
 
         // Get the Mandate info
         $mandate = (array) $provider->getMandate($wallet);
 
         $mandate['amount'] = $mandate['minAmount'] = round($wallet->getMinMandateAmount() / 100, 2);
         $mandate['balance'] = 0;
         $mandate['isDisabled'] = !empty($mandate['id']) && $settings['mandate_disabled'];
         $mandate['isValid'] = !empty($mandate['isValid']);
 
         foreach (['amount', 'balance'] as $key) {
             if (($value = $settings["mandate_{$key}"]) !== null) {
                 $mandate[$key] = $value;
             }
         }
 
         // Unrestrict the wallet owner if mandate is valid
         if (!empty($mandate['isValid']) && $wallet->owner->isRestricted()) {
             $wallet->owner->unrestrict();
         }
 
         return $mandate;
     }
 
     /**
      * List supported payment methods.
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function paymentMethods(Request $request)
     {
         $user = $this->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 function hasPayments(Request $request)
     {
         $user = $this->guard()->user();
 
         // TODO: Wallet selection
         $wallet = $user->wallets()->first();
 
         $exists = Payment::where('wallet_id', $wallet->id)
             ->where('type', Payment::TYPE_ONEOFF)
             ->whereIn('status', [
                     Payment::STATUS_OPEN,
                     Payment::STATUS_PENDING,
                     Payment::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 function payments(Request $request)
     {
         $user = $this->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', Payment::TYPE_ONEOFF)
             ->whereIn('status', [
                     Payment::STATUS_OPEN,
                     Payment::STATUS_PENDING,
                     Payment::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) use ($wallet) {
             $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,
                 'currency' => $wallet->currency,
                 // note: $item->currency/$item->currency_amount might be different
                 '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,
         ]);
     }
 
     /**
      * Calculates tax for the payment, fills the request with additional properties
      *
      * @param \App\Wallet $wallet  The wallet
      * @param array       $request The request data with the payment amount
      */
     protected static function addTax(Wallet $wallet, array &$request): void
     {
         $request['vat_rate_id'] = null;
         $request['credit_amount'] = $request['amount'];
 
         if ($rate = $wallet->vatRate()) {
             $request['vat_rate_id'] = $rate->id;
 
             switch (\config('app.vat.mode')) {
                 case 1:
                     // In this mode tax is added on top of the payment. The amount
                     // to pay grows, but we keep wallet balance without tax.
                     $request['amount'] = $request['amount'] + round($request['amount'] * $rate->rate / 100);
                     break;
 
                 default:
                     // In this mode tax is "swallowed" by the vendor. The payment
                     // amount does not change
                     break;
             }
         }
     }
 }
diff --git a/src/app/Providers/Payment/Stripe.php b/src/app/Providers/Payment/Stripe.php
index 64617d4a..43f66120 100644
--- a/src/app/Providers/Payment/Stripe.php
+++ b/src/app/Providers/Payment/Stripe.php
@@ -1,555 +1,555 @@
 <?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.
      *                             - redirectUrl: The location to goto after checkout
      *
      * @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' => $payment['redirectUrl'] ?? self::redirectUrl(), // required
             'success_url' => $payment['redirectUrl'] ?? self::redirectUrl(), // 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['credit_amount'] = 0;
         $payment['currency_amount'] = 0;
         $payment['vat_rate_id'] = null;
         $payment['id'] = $session->setup_intent;
         $payment['type'] = Payment::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'] == Payment::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' => self::redirectUrl(), // required
             'success_url' => self::redirectUrl(), // required
             'payment_method_types' => ['card'], // required
             'locale' => 'en',
             'line_items' => [
                 [
                     'name' => $payment['description'],
                     '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' => $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 == Payment::TYPE_MANDATE) {
                     return 404;
                 }
 
                 switch ($intent->status) {
                     case StripeAPI\PaymentIntent::STATUS_CANCELED:
                         $status = Payment::STATUS_CANCELED;
                         break;
                     case StripeAPI\PaymentIntent::STATUS_SUCCEEDED:
                         $status = Payment::STATUS_PAID;
                         break;
                     default:
                         $status = Payment::STATUS_FAILED;
                 }
 
                 DB::beginTransaction();
 
                 if ($status == Payment::STATUS_PAID) {
                     // Update the balance, if it wasn't already
                     if ($payment->status != Payment::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 != Payment::STATUS_PAID) {
                     $payment->status = $status;
                     $payment->save();
 
                     if ($status != Payment::STATUS_CANCELED && $payment->type == Payment::TYPE_RECURRING) {
                         // Disable the mandate
                         if ($status == Payment::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 != Payment::TYPE_MANDATE) {
                     return 404;
                 }
 
                 switch ($intent->status) {
                     case StripeAPI\SetupIntent::STATUS_CANCELED:
                         $status = Payment::STATUS_CANCELED;
                         break;
                     case StripeAPI\SetupIntent::STATUS_SUCCEEDED:
                         $status = Payment::STATUS_PAID;
                         break;
                     default:
                         $status = Payment::STATUS_FAILED;
                 }
 
                 if ($status == Payment::STATUS_PAID) {
                     $payment->wallet->setSetting('stripe_mandate_id', $intent->id);
-                    $threshold = intval((float) $payment->wallet->getSetting('mandate_balance') * 100);
+                    $threshold = (int) round((float) $payment->wallet->getSetting('mandate_balance') * 100);
 
                     // Call credit() so wallet/account state is updated
                     $this->creditPayment($payment, $intent);
 
                     // Top-up the wallet if balance is below the threshold
                     if ($payment->wallet->balance < $threshold && $payment->status != Payment::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);
         }
 
         $payment->credit($method);
     }
 
     /**
      * 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).
      * @param string $currency Currency code
      *
      * @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(string $type, string $currency): array
     {
         //TODO get this from the stripe API?
         $availableMethods = [];
         switch ($type) {
             case Payment::TYPE_ONEOFF:
                 $availableMethods = [
                     self::METHOD_CREDITCARD => [
                         'id' => self::METHOD_CREDITCARD,
                         'name' => "Credit Card",
                         'minimumAmount' => Payment::MIN_AMOUNT,
                         'currency' => $currency,
                         'exchangeRate' => 1.0
                     ],
                     self::METHOD_PAYPAL => [
                         'id' => self::METHOD_PAYPAL,
                         'name' => "PayPal",
                         'minimumAmount' => Payment::MIN_AMOUNT,
                         'currency' => $currency,
                         'exchangeRate' => 1.0
                     ]
                 ];
                 break;
             case Payment::TYPE_RECURRING:
                 $availableMethods = [
                     self::METHOD_CREDITCARD => [
                         'id' => self::METHOD_CREDITCARD,
                         'name' => "Credit Card",
                         'minimumAmount' => Payment::MIN_AMOUNT, // Converted to cents,
                         'currency' => $currency,
                         '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/tests/Feature/Controller/Admin/WalletsTest.php b/src/tests/Feature/Controller/Admin/WalletsTest.php
index 62d6ca40..c8d7bac7 100644
--- a/src/tests/Feature/Controller/Admin/WalletsTest.php
+++ b/src/tests/Feature/Controller/Admin/WalletsTest.php
@@ -1,234 +1,234 @@
 <?php
 
 namespace Tests\Feature\Controller\Admin;
 
 use App\Discount;
 use App\Transaction;
 use Tests\TestCase;
 
 class WalletsTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
         self::useAdminUrl();
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         parent::tearDown();
     }
 
     /**
      * Test fetching a wallet (GET /api/v4/wallets/:id)
      *
      * @group stripe
      */
     public function testShow(): void
     {
         \config(['services.payment_provider' => 'stripe']);
 
         $user = $this->getTestUser('john@kolab.org');
         $admin = $this->getTestUser('jeroen@jeroen.jeroen');
         $wallet = $user->wallets()->first();
         $wallet->discount_id = null;
         $wallet->save();
 
         // Make sure there's no stripe/mollie identifiers
         $wallet->setSetting('stripe_id', null);
         $wallet->setSetting('stripe_mandate_id', null);
         $wallet->setSetting('mollie_id', null);
         $wallet->setSetting('mollie_mandate_id', null);
 
         // Non-admin user
         $response = $this->actingAs($user)->get("api/v4/wallets/{$wallet->id}");
         $response->assertStatus(403);
 
         // Admin user
         $response = $this->actingAs($admin)->get("api/v4/wallets/{$wallet->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame($wallet->id, $json['id']);
         $this->assertSame('CHF', $json['currency']);
         $this->assertSame($wallet->balance, $json['balance']);
         $this->assertSame(0, $json['discount']);
         $this->assertTrue(empty($json['description']));
         $this->assertTrue(empty($json['discount_description']));
         $this->assertTrue(!empty($json['provider']));
         $this->assertTrue(empty($json['providerLink']));
         $this->assertTrue(!empty($json['mandate']));
     }
 
     /**
      * Test awarding/penalizing a wallet (POST /api/v4/wallets/:id/one-off)
      */
     public function testOneOff(): void
     {
         $user = $this->getTestUser('john@kolab.org');
         $admin = $this->getTestUser('jeroen@jeroen.jeroen');
         $wallet = $user->wallets()->first();
         $balance = $wallet->balance;
         $reseller = $this->getTestUser('reseller@' . \config('app.domain'));
         $wallet = $user->wallets()->first();
         $reseller_wallet = $reseller->wallets()->first();
         $reseller_balance = $reseller_wallet->balance;
 
         Transaction::where('object_id', $wallet->id)
             ->whereIn('type', [Transaction::WALLET_AWARD, Transaction::WALLET_PENALTY])
             ->delete();
 
         // Non-admin user
         $response = $this->actingAs($user)->post("api/v4/wallets/{$wallet->id}/one-off", []);
         $response->assertStatus(403);
 
         // Admin user - invalid input
         $post = ['amount' => 'aaaa'];
         $response = $this->actingAs($admin)->post("api/v4/wallets/{$wallet->id}/one-off", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame('The amount must be a number.', $json['errors']['amount'][0]);
         $this->assertSame('The description field is required.', $json['errors']['description'][0]);
         $this->assertCount(2, $json);
         $this->assertCount(2, $json['errors']);
 
         // Admin user - a valid bonus
-        $post = ['amount' => '50', 'description' => 'A bonus'];
+        $post = ['amount' => '17.40', 'description' => 'A bonus'];
         $response = $this->actingAs($admin)->post("api/v4/wallets/{$wallet->id}/one-off", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('The bonus has been added to the wallet successfully.', $json['message']);
-        $this->assertSame($balance += 5000, $json['balance']);
+        $this->assertSame($balance += 1740, $json['balance']);
         $this->assertSame($balance, $wallet->fresh()->balance);
         $this->assertSame($reseller_balance, $reseller_wallet->fresh()->balance);
 
         $transaction = Transaction::where('object_id', $wallet->id)
             ->where('type', Transaction::WALLET_AWARD)->first();
 
         $this->assertSame($post['description'], $transaction->description);
-        $this->assertSame(5000, $transaction->amount);
+        $this->assertSame(1740, $transaction->amount);
         $this->assertSame($admin->email, $transaction->user_email);
 
         // Admin user - a valid penalty
-        $post = ['amount' => '-40', 'description' => 'A penalty'];
+        $post = ['amount' => '-17.40', 'description' => 'A penalty'];
         $response = $this->actingAs($admin)->post("api/v4/wallets/{$wallet->id}/one-off", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('The penalty has been added to the wallet successfully.', $json['message']);
-        $this->assertSame($balance -= 4000, $json['balance']);
+        $this->assertSame($balance -= 1740, $json['balance']);
         $this->assertSame($balance, $wallet->fresh()->balance);
         $this->assertSame($reseller_balance, $reseller_wallet->fresh()->balance);
 
         $transaction = Transaction::where('object_id', $wallet->id)
             ->where('type', Transaction::WALLET_PENALTY)->first();
 
         $this->assertSame($post['description'], $transaction->description);
-        $this->assertSame(-4000, $transaction->amount);
+        $this->assertSame(-1740, $transaction->amount);
         $this->assertSame($admin->email, $transaction->user_email);
     }
 
     /**
      * Test fetching wallet transactions (GET /api/v4/wallets/:id/transactions)
      */
     public function testTransactions(): void
     {
         // Note: Here we're testing only that the end-point works,
         // and admin can get the transaction log, response details
         // are tested in Feature/Controller/WalletsTest.php
         $this->deleteTestUser('wallets-controller@kolabnow.com');
         $user = $this->getTestUser('wallets-controller@kolabnow.com');
         $wallet = $user->wallets()->first();
         $admin = $this->getTestUser('jeroen@jeroen.jeroen');
 
         // Non-admin
         $response = $this->actingAs($user)->get("api/v4/wallets/{$wallet->id}/transactions");
         $response->assertStatus(403);
 
         // Create some sample transactions
         $transactions = $this->createTestTransactions($wallet);
         $transactions = array_reverse($transactions);
         $pages = array_chunk($transactions, 10 /* page size*/);
 
         // Get the 2nd page
         $response = $this->actingAs($admin)->get("api/v4/wallets/{$wallet->id}/transactions?page=2");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(5, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame(2, $json['page']);
         $this->assertSame(2, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertCount(2, $json['list']);
         foreach ($pages[1] as $idx => $transaction) {
             $this->assertSame($transaction->id, $json['list'][$idx]['id']);
             $this->assertSame($transaction->type, $json['list'][$idx]['type']);
             $this->assertSame($transaction->shortDescription(), $json['list'][$idx]['description']);
             $this->assertFalse($json['list'][$idx]['hasDetails']);
         }
 
         // The 'user' key is set only on the admin end-point
         $this->assertSame('jeroen@jeroen.jeroen', $json['list'][1]['user']);
     }
 
     /**
      * Test updating a wallet (PUT /api/v4/wallets/:id)
      */
     public function testUpdate(): void
     {
         $user = $this->getTestUser('john@kolab.org');
         $admin = $this->getTestUser('jeroen@jeroen.jeroen');
         $wallet = $user->wallets()->first();
         $discount = Discount::where('code', 'TEST')->first();
 
         // Non-admin user
         $response = $this->actingAs($user)->put("api/v4/wallets/{$wallet->id}", []);
         $response->assertStatus(403);
 
         // Admin user - setting a discount
         $post = ['discount' => $discount->id];
         $response = $this->actingAs($admin)->put("api/v4/wallets/{$wallet->id}", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('User wallet updated successfully.', $json['message']);
         $this->assertSame($wallet->id, $json['id']);
         $this->assertSame($discount->discount, $json['discount']);
         $this->assertSame($discount->id, $json['discount_id']);
         $this->assertSame($discount->description, $json['discount_description']);
         $this->assertSame($discount->id, $wallet->fresh()->discount->id);
 
         // Admin user - removing a discount
         $post = ['discount' => null];
         $response = $this->actingAs($admin)->put("api/v4/wallets/{$wallet->id}", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame('User wallet updated successfully.', $json['message']);
         $this->assertSame($wallet->id, $json['id']);
         $this->assertSame(null, $json['discount_id']);
         $this->assertTrue(empty($json['discount_description']));
         $this->assertSame(null, $wallet->fresh()->discount);
     }
 }