Fix: Fixing various bugs occured on payment lifecycle

config/payment.php

@@ -14,18 +14,20 @@ return [
     | Lunar's own config.
     |
     | 'payment_driver' is boboko-owned, alongside Lunar's own 'driver' key —
-    | it's the Modules\Core\Payment\Contracts\PaymentDriver class
-    | CheckoutService::confirmPayment() resolves via the container and calls
-    | confirm() on. Kept on the same row as 'driver' rather than a second,
-    | separately-keyed map, so a type's full definition — Lunar's driver,
-    | its config, and its PaymentDriver — lives in one place.
+    | the driver instance Modules\Core\Payment\Services\PaymentDriverResolver
+    | resolves via the container. 'capture_mode' ('pay' or 'authorize') is
+    | also boboko-owned — which contract method
+    | CheckoutService::initiatePayment() calls for this type. Kept on the
+    | same row as 'driver' rather than a second, separately-keyed map, so a
+    | type's full definition lives in one place.
     |
     */
     'types' => [
         'cash-on-delivery' => [
             'driver' => 'offline',
             'payment_driver' => OfflinePaymentDriver::class,
-            'authorized' => 'awaiting-payment',
+            'capture_mode' => 'pay',
+            'captured_status' => 'payment-offline',
             'fee' => 0,
         ],
     ],

database/migrations/2026_09_03_000002_add_context_to_stripe_payment_intents.php

@@ -0,0 +1,47 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+use Lunar\Base\Migration;
+
+/**
+ * lunarphp/stripe's own stripe_payment_intents table already correlates a
+ * Stripe intent back to a cart/order via cart_id/order_id — exactly what
+ * Modules\Core\Payment\Drivers\StripePaymentDriver needs to recover
+ * $context in handleCallback(), a separate request (a webhook) from the
+ * pay()/authorize() call that originated it. Two columns this driver
+ * needs that the vendor table doesn't have:
+ *   - context: the full opaque $context bag pay()/authorize() received,
+ *     stored so handleCallback() can dispatch the SAME context the
+ *     original call would have, without Payment inventing its own
+ *     correlation table — see docs/payments.md "Async resolution".
+ *   - payment_type: the payment type key (e.g. 'stripe') pay()/authorize()
+ *     were called with — needed to dispatch Payment events with the
+ *     correct $type in handleCallback(), which otherwise has no way to
+ *     know it (a webhook payload doesn't carry it).
+ *
+ * Extends Lunar\Base\Migration (not the plain base Migration) so $this->prefix
+ * resolves the SAME table-prefix config every Lunar-owned table uses
+ * (config('lunar.database.table_prefix')) — the vendor migration that
+ * creates this table (lunarphp/stripe's create_stripe_payment_intents_table)
+ * already does this, so a store running with a non-default prefix (this
+ * one runs with 'lunar_') would otherwise have this migration fail against
+ * a table name that doesn't exist.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table($this->prefix.'stripe_payment_intents', function (Blueprint $table) {
+            $table->json('context')->nullable()->after('status');
+            $table->string('payment_type')->nullable()->after('context');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table($this->prefix.'stripe_payment_intents', function (Blueprint $table) {
+            $table->dropColumn(['context', 'payment_type']);
+        });
+    }
+};

docs/payments.md

@@ -0,0 +1,189 @@
+# Payment — Design Notes
+
+**Status: abstraction layer built, drivers/wiring in progress.** `Payment` is designed as a
+standalone module: it never calls into `Checkout` or `Order`, never touches their Eloquent
+models, and communicates only via events. This document is the design spec for that
+abstraction — contracts, DTOs, events — independent of how `Checkout`/`Order` end up consuming
+it (that wiring is a separate, later pass).
+
+---
+
+## Operations, not gateways
+
+The driver contracts model the actual operations a payment gateway can perform, not vendor
+terminology. Every real gateway checked while designing this converges on the same small set
+under different names:
+
+| Operation | Mastercard | Stripe | Nexi |
+|---|---|---|---|
+| Atomic charge (authorize+capture in one call) | `Pay` | `capture_method: automatic` | `ActionType::PAY()` |
+| Hold only, settle/release later | `Authorize` | `capture_method: manual` | `ActionType::PREAUTH()` |
+| Settle a prior hold | `Capture` | `PaymentIntent::capture()` | `CaptureRequest`/`CaptureResponse` |
+| Release a prior hold without settling | `Void`/`Cancel` | `PaymentIntent::cancel()` | `CancelRequest`/`CancelResponse` |
+| Reverse settled funds | `Refund` | `Refund::create()` | (refund endpoint) |
+
+A driver implements only the interfaces its gateway actually supports:
+
+- An offline/cash type (`cash-on-delivery`, `cash-in-hand`) only ever settles atomically —
+  implements `SupportsPay` alone.
+- A card gateway capable of either mode per-transaction (Stripe, most card processors)
+  implements `SupportsPay`, `SupportsAuthorization`, `SupportsCaptures`, `SupportsVoids`, and
+  `SupportsRefunds` all at once — which one gets *called* for a given attempt is the caller's
+  policy choice (e.g. `config('lunar.stripe.policy')`), not something baked into the driver's
+  shape.
+- A redirect/wallet gateway with no separate hold step (Viva/Klarna in typical flows)
+  implements `SupportsPay` and `SupportsRefunds`, never `SupportsCaptures`/`SupportsVoids`.
+
+### `pay()` and `authorize()` stay separate methods even when a gateway implements both as "the same call with a flag"
+
+Stripe has no separate `authorize`/`pay` API endpoints — one `PaymentIntent`, confirmed with
+either `capture_method: automatic` or `manual`. Mastercard and Nexi *do* have genuinely
+separate operations. The contract abstracts over both shapes uniformly: every driver capable
+of both exposes two distinct methods, `pay()` and `authorize()`. A Mastercard-style driver
+calls two different endpoints under the hood; a Stripe-style driver calls the same endpoint
+twice with a different flag each time. Neither difference is visible to a caller.
+
+### `capture()`/`void()` are only ever valid against a prior `authorize()`
+
+They are not standalone operations — `capture()` settles a specific hold identified by the
+`reference` `authorize()` returned; `void()` releases that same hold instead. A driver that
+never implements `SupportsAuthorization` never produces a reference either of these methods
+could act on.
+
+---
+
+## `PaymentResult` — the one return shape, every operation, every driver
+
+```php
+enum PaymentResultStatus { case Succeeded; case Failed; case Pending; }
+
+final class PaymentResult {
+    public function __construct(
+        public readonly PaymentResultStatus $status,
+        public readonly string $reference,
+        public readonly int $amount,
+        public readonly ?string $failureReason = null,
+        public readonly bool $retriable = false,
+        public readonly array $raw = [],
+        public readonly array $meta = [],
+    ) {}
+}
+```
+
+Real gateway responses vary wildly in richness — confirmed by reading three SDKs directly:
+
+- **Stripe's `PaymentIntent`** is rich: `status`, `amount`, `amount_capturable`,
+  `amount_received`, `last_payment_error`, a full `getLastResponse()`.
+- **Nexi's `CaptureResponse`/`CancelResponse`** are minimal: just `operationId` +
+  `operationTime` — no echoed amount or status at all. Success is inferred from getting a
+  response rather than an SDK exception.
+- **Mastercard's** gateway sits in between, with `gatewayCode`/`acquirerCode`/
+  `merchantAdviceCode`.
+
+`PaymentResult` only requires what every driver can always know: `status`, `reference`,
+`amount` (the amount **we** requested — not necessarily echoed back by a sparse gateway like
+Nexi's capture). Everything else is best-effort: `failureReason`/`retriable` are normalized
+only when the gateway has something to normalize from; `raw` is the unconditional escape
+hatch — the untouched gateway response body, always populated, for genuine audit fidelity
+regardless of how sparse the normalized fields ended up.
+
+### `retriable` — real on some gateways, absent on others
+
+Stripe classifies declines as soft (`do_not_honor`, `insufficient_funds` — worth retrying,
+after a delay) vs. hard (`stolen_card`, `expired_card` — never retry the same method).
+Mastercard has the equivalent via `authorizationResponse.merchantAdviceCode` and card-scheme
+soft-decline codes. **Nexi has no such signal at all** — `OperationResult` is just
+`DECLINED`/`DENIED_BY_RISK`/`FAILED`/etc. with no retriability classification. `retriable`
+therefore defaults to `false` (assume not safely retriable) rather than guessing when a
+driver's gateway has nothing to base it on.
+
+---
+
+## Events — one terminal pair per operation, keyed to the business fact, not the call path
+
+`Modules\Core\Payment\Events`:
+
+| Event pair | Dispatched by |
+|---|---|
+| `PaymentAuthorized` / `PaymentAuthorizationFailed` | `SupportsAuthorization::authorize()`, or a later `HandlesPaymentCallback::handleCallback()` resolving it |
+| `PaymentCaptured` / `PaymentCaptureFailed` | `SupportsPay::pay()` **or** `SupportsCaptures::capture()` |
+| `PaymentVoided` / `PaymentVoidFailed` | `SupportsVoids::void()` |
+| `PaymentRefunded` / `PaymentRefundFailed` | `SupportsRefunds::refund()` |
+
+`PaymentCaptured` is deliberately the *same* event whether money was taken via `pay()` (one
+gateway call) or `authorize()` → `capture()` (two calls) — "a payment has been captured" is
+the same business fact either way, and a listener reacting to it never needs to know which
+path produced it. There is no separate "payment succeeded" wrapper event distinct from
+`PaymentCaptured`.
+
+Every event carries `{type: string, result: PaymentResult, context: array}`. `Payment` has no
+concept of a `Cart`, an `Order`, or a checkout fingerprint — `$context` is an opaque bag the
+caller hands in on the way down (`pay($type, $data, $context)`) and gets back untouched on
+whichever event that call (or a later `handleCallback()`) produces. Each listener interprets
+`$context` on its own terms, or ignores the event if the keys it needs aren't present —
+`Checkout` is only one possible consumer of these events, not the only one.
+
+---
+
+## Async resolution — `HandlesPaymentCallback`
+
+Only implemented by a driver whose `pay()`/`authorize()` can return `PaymentResultStatus::Pending`
+— a redirect the shopper completes elsewhere, a webhook that arrives later. A driver whose
+gateway always resolves synchronously never implements this.
+
+```php
+public function handleCallback(string $reference, array $data, array $context = []): PaymentResult;
+```
+
+Resolves into the *same* event pair the original `pay()`/`authorize()` call would have
+produced had it resolved synchronously.
+
+### The correlation problem: `handleCallback()` runs in a different request
+
+`$context` passed into the original `pay()`/`authorize()` call does not survive to
+`handleCallback()` on its own — that call is typically a separate HTTP request (a webhook)
+with no memory of the request that started the payment. Something has to persist enough to
+answer "which order/cart does gateway reference X belong to?" between the two calls.
+
+**Read directly from `lunarphp/stripe`'s own source** (`StripePaymentType::authorize()`,
+`ProcessStripeWebhook`, `WebhookController`) to see how Lunar itself solves this — confirmed
+it does **not** stash a generic opaque blob. It writes the correlating ids as real, typed
+columns on `Lunar\Stripe\Models\StripePaymentIntent` (`cart_id`, `order_id`) at the moment the
+intent is created/first seen, then reads them back the same way when the webhook arrives:
+
+```php
+// ProcessStripeWebhook::handle() — falls back through two real lookups,
+// neither of them a generic context blob:
+$cart = StripePaymentIntent::where('intent_id', $this->paymentIntentId)->first()?->cart
+    ?: Cart::where('meta->payment_intent', '=', $this->paymentIntentId)->first();
+```
+
+**`StripePaymentDriver` follows this exact precedent**: it reads `cart_id`/`order_id` out of
+`$context` at `pay()`/`authorize()` time and writes them onto its own `StripePaymentIntent`
+row (a table already owned by `lunarphp/stripe`, already shaped for exactly this), then reads
+them back the same way in `handleCallback()`. No generic `context` json column, no new table.
+
+### This pattern is per-driver, not a shared table
+
+`stripe_payment_intents` is Stripe-specific — keyed on `intent_id`, typed around
+`Stripe\PaymentIntent`'s own status values. It cannot be reused as-is for a future non-Stripe
+async driver (Nexi, Viva): that driver's own gateway reference has a different shape entirely,
+and shoehorning it into Stripe-named columns would make the table misleading. The **pattern**
+generalizes — *any* driver needing async callback resolution owns a small table keyed by its
+own gateway's reference, storing whatever correlation data that driver specifically needs —
+but each driver gets its own table, matching what it actually needs to correlate, rather than
+a shared generic one.
+
+---
+
+## Explicitly out of scope for this pass
+
+- **`Checkout`/`Order` wiring** — how `Checkout` calls into `Payment`, how `Order`/`Checkout`
+  react to `Payment`'s events, where a draft `Order` gets created relative to when `Payment` is
+  called. Deliberately designed and built separately, after `Payment` itself was complete —
+  `Payment` must stand on its own regardless of what ends up consuming it.
+- **`Transaction` persistence** — Lunar's own `transactions` table (`type`: `intent`/`capture`/
+  `refund`, `parent_transaction_id` chaining) already models the audit trail these events
+  would feed, once a listener is built to write to it. `Payment` itself does not write
+  `Transaction` rows — see the events table above; that is a listener's job, in whichever
+  module ends up owning the write (likely `Order`, since `Transaction.order_id` is required).

src/Checkout/Contracts/PaymentDriver.php

@@ -1,62 +0,0 @@
-<?php
-
-namespace Modules\Core\Checkout\Contracts;
-
-use Lunar\Exceptions\FingerprintMismatchException;
-use Lunar\Exceptions\Carts\CartException;
-use Lunar\Models\Cart;
-use Lunar\Models\Order;
-
-/**
- * A boboko-owned payment driver — wraps a payment gateway's own confirmation
- * mechanics (Stripe's synchronous authorize() call, a redirect-based
- * provider's async callback/webhook, anything else) behind one uniform
- * moment: "payment is confirmed, place the order."
- *
- * confirm() is the only thing a driver is required to do: once it has,
- * by whatever mechanism is native to that gateway, independently decided
- * the payment succeeded, it calls Modules\Core\Checkout\Services\
- * CheckoutService::placeOrder($fingerprint) itself — no driver ever calls
- * Lunar\Models\Cart::createOrder() directly. This is what lets the
- * storefront checkout sequence stay uniform regardless of which provider is
- * active: set addresses, select shipping, hand off to whichever driver is
- * configured, and the driver decides when (or whether) the order actually
- * gets created. See docs/checkout.md / docs/payments.md.
- */
-interface PaymentDriver
-{
-    /**
-     * Whether this driver can actually be used right now — e.g. Stripe
-     * checking its own API key is present, an offline-style driver always
-     * returning true since it has no external dependency. Independent of
-     * Modules\Core\Payment\Models\PaymentMethod::enabled (the admin
-     * on/off toggle) — CheckoutService::getPaymentMethods() combines both:
-     * a type is only offered to the storefront if it's administratively
-     * enabled AND its driver reports itself configured.
-     */
-    public function isConfigured(): bool;
-
-    /**
-     * $type is the payment type key being confirmed (e.g. 'cash-in-hand',
-     * 'cash-on-delivery', 'stripe') — passed through even though most
-     * drivers only ever serve one type, because a driver shared across
-     * several types (e.g. one "no real confirmation" offline driver behind
-     * both cash-in-hand and cash-on-delivery) needs it to look up that
-     * type's own config (e.g. its 'authorized' status) rather than another
-     * type's.
-     *
-     * $data carries whatever the gateway needs to confirm this specific
-     * payment (Stripe: ['payment_intent' => $id], a redirect-based
-     * provider: its callback payload) — passed explicitly by the caller
-     * (a controller, a webhook job) rather than a driver reaching into the
-     * global request(), so confirm() works the same whether it's called
-     * from a synchronous HTTP request or an async webhook/job with no
-     * active request at all.
-     *
-     * @param  array<string, mixed>  $data
-     *
-     * @throws FingerprintMismatchException
-     * @throws CartException
-     */
-    public function confirm(Cart $cart, string $type, string $fingerprint, array $data): Order;
-}

src/Checkout/Events/OrderPlaced.php

@@ -5,13 +5,17 @@ namespace Modules\Core\Checkout\Events;
 use Lunar\Models\Order;
 
 /**
- * Dispatched by CheckoutService::placeOrder() the moment an Order exists —
- * the handoff point between Checkout and Order (see docs/checkout.md's
- * "Three-stage lifecycle"). Checkout has no opinion about what happens
- * after this fires; Order's own listeners (not built yet — Order is a
- * named-but-unscoped concern, same status Recovery had before it existed)
- * would be what reacts to it — e.g. a confirmation email, initializing
- * order status tracking.
+ * Dispatched once an Order's placed_at is set — the handoff point between
+ * Checkout/Payment and Order (see docs/checkout.md's "Three-stage
+ * lifecycle"). Fired by Modules\Core\Order\Listeners\
+ * ApplyResolvedPaymentStatus once it resolves a PaymentCaptured/
+ * PaymentAuthorized event into an actual order status change, not by
+ * CheckoutService directly — a draft Order can exist (via
+ * CheckoutService::initiatePayment()) well before this fires, if payment
+ * resolves asynchronously (e.g. a redirect-based gateway). Checkout has no
+ * opinion about what happens after this fires; Order's own listeners are
+ * what react to it — e.g. a confirmation email, initializing order status
+ * tracking.
  */
 class OrderPlaced
 {

src/Checkout/Events/PaymentConfirmed.php

@@ -1,36 +0,0 @@
-<?php
-
-namespace Modules\Core\Checkout\Events;
-
-use Illuminate\Foundation\Events\Dispatchable;
-use Lunar\Models\Cart;
-
-/**
- * Dispatched by a PaymentDriver once it has independently decided (by
- * whatever mechanism is native to its gateway) that payment succeeded —
- * the event-driven counterpart to what used to be a direct
- * CheckoutService::placeOrder() call from inside confirm(). Listened to by
- * CheckoutService itself, which places the order and dispatches
- * OrderPlaced.
- *
- * $type/$data are carried through for the same reason PaymentDriver::
- * confirm() takes them — a driver-specific post-placement step (e.g.
- * OfflinePaymentDriver's status mapping, StripePaymentDriver's
- * UpdateOrderFromIntent) still needs them, but can no longer receive the
- * placed Order as a return value. Each driver instead listens for
- * OrderPlaced and checks $order->meta['payment_method'] against its own
- * type(s) to recognize which OrderPlaced is its own — carrying $fingerprint
- * here too lets a driver correlate its own OrderPlaced listener call back
- * to the specific confirmation that triggered it, if it needs to.
- */
-class PaymentConfirmed
-{
-    use Dispatchable;
-
-    public function __construct(
-        public readonly Cart $cart,
-        public readonly string $type,
-        public readonly string $fingerprint,
-        public readonly array $data = [],
-    ) {}
-}

src/Checkout/Services/CheckoutService.php

@@ -10,16 +10,14 @@ use Lunar\Base\Addressable;
 use Lunar\DataTypes\ShippingOption;
 use Lunar\Facades\ShippingManifest;
 use Lunar\Models\Cart;
-use Lunar\Models\Order;
 use Modules\Core\Cart\Services\CartService;
 use Modules\Core\Checkout\Events\BillingAddressSet;
-use Modules\Core\Checkout\Events\OrderPlaced;
-use Modules\Core\Checkout\Events\PaymentConfirmed;
 use Modules\Core\Checkout\Events\PaymentMethodSelected;
 use Modules\Core\Checkout\Events\ShippingAddressSet;
 use Modules\Core\Checkout\Events\ShippingOptionSelected;
 use Modules\Core\Checkout\Exceptions\InvalidShippingOptionException;
 use Modules\Core\Checkout\Exceptions\UnknownPaymentTypeException;
+use Modules\Core\Payment\DTOs\PaymentResult;
 use Modules\Core\Payment\Models\PaymentMethod;
 use Modules\Core\Payment\Services\PaymentDriverResolver;
 
@@ -30,9 +28,11 @@ use Modules\Core\Payment\Services\PaymentDriverResolver;
  * implementation detail. See docs/checkout.md for the full design —
  * Checkout is the middle of a three-stage lifecycle (Cart → Checkout →
  * Order): it owns the placement moment itself (address, shipping selection,
- * placeOrder()) and ends the instant an Order exists. What happens to that
- * Order afterward (status transitions, fulfillment) is deliberately out of
- * scope here — see OrderPlaced's docblock.
+ * ensuring a draft Order exists) and hands off to Payment the instant that
+ * draft exists — see initiatePayment(). What happens to that Order
+ * afterward (status transitions, fulfillment) is deliberately out of
+ * scope here — see docs/payments.md and Checkout\Events\OrderPlaced's
+ * docblock for where that now lives.
  *
  * Depends on CartService for cart access rather than reaching into
  * Lunar\Facades\CartSession directly a second time, so Checkout stays
@@ -99,47 +99,12 @@ class CheckoutService
         return $cart;
     }
 
-    /**
-     * $fingerprint is mandatory, not optional — the caller must prove the
-     * cart total the shopper last saw (Cart::fingerprint()) still matches
-     * before an order is placed. Cart::checkFingerprint() throws Lunar's own
-     * FingerprintMismatchException on a mismatch (a line's price changed,
-     * stock adjusted the total, another tab modified the cart) rather than
-     * silently placing an order at a different total than what was shown.
-     *
-     * Not called directly by a storefront — see confirmPayment(), which is
-     * the only caller and supplies the fingerprint captured in
-     * selectPaymentMethod(), not one the storefront has to obtain itself.
-     *
-     * No exception wrapping: Lunar\Validation\Cart\ValidateCartForOrderCreation
-     * (run inside Cart::createOrder()) already throws
-     * Lunar\Exceptions\Carts\CartException with a field-keyed MessageBag
-     * ($exception->errors()) for address/shipping-option validation and the
-     * duplicate-order guard — already the right shape for a storefront to
-     * render as form errors directly. FingerprintMismatchException
-     * propagates the same way, for the same reason.
-     *
-     * @throws FingerprintMismatchException
-     * @throws CartException
-     */
-    public function placeOrder(string $fingerprint): Order
-    {
-        $cart = $this->cart->currentOrCreate();
-        $cart->checkFingerprint($fingerprint);
-
-        $order = $cart->createOrder();
-
-        Event::dispatch(new OrderPlaced($order));
-
-        return $order;
-    }
-
     /**
      * Every payment type currently offered to the storefront — every key
      * in config('lunar.payments.types') that is BOTH administratively
      * enabled (Modules\Core\Payment\Models\PaymentMethod::enabled) AND
-     * whose registered PaymentDriver reports itself usable right now
-     * (PaymentDriver::isConfigured() — e.g. Stripe with no API key set is
+     * whose registered driver reports itself usable right now
+     * (Configurable::isConfigured() — e.g. Stripe with no API key set is
      * never offered, regardless of the enabled toggle). A type with no
      * PaymentMethod row at all (never seeded) is treated as not offered,
      * same as disabled — nothing here creates one; see
@@ -167,13 +132,13 @@ class CheckoutService
      * including any payment-type-specific adjustment (e.g. a COD
      * surcharge), which only exists once payment_method is set and the
      * cart recalculates. Captured here, server-side, rather than asked of
-     * the storefront: this is the last moment before confirmPayment() that
-     * the shopper's reviewed total is known, and confirmPayment() reads it
+     * the storefront: this is the last moment before initiatePayment() that
+     * the shopper's reviewed total is known, and initiatePayment() reads it
      * back internally instead of taking a fingerprint parameter — a
      * storefront should never need to know Cart::fingerprint() exists.
      *
-     * Does not itself call a PaymentDriver — selecting a method and
-     * confirming payment against it are deliberately separate steps, same
+     * Does not itself call a payment driver — selecting a method and
+     * initiating payment against it are deliberately separate steps, same
      * as selecting a shipping option happens before placing the order.
      *
      * @throws UnknownPaymentTypeException if $type isn't currently offered
@@ -187,11 +152,11 @@ class CheckoutService
         }
 
         $cart = $this->cart->currentOrCreate();
-        $cart->meta = [...$cart->meta->toArray(), 'payment_method' => $type];
+        $cart->meta = [...($cart->meta?->toArray() ?? []), 'payment_method' => $type];
         $cart->save();
 
         $cart = $cart->calculate();
-        $cart->meta = [...$cart->meta->toArray(), 'checkout_fingerprint' => $cart->fingerprint()];
+        $cart->meta = [...($cart->meta?->toArray() ?? []), 'checkout_fingerprint' => $cart->fingerprint()];
         $cart->save();
 
         Event::dispatch(new PaymentMethodSelected($cart, $type));
@@ -200,44 +165,76 @@ class CheckoutService
     }
 
     /**
-     * Resolves $type's registered PaymentDriver and calls confirm() — the
-     * driver independently decides whether payment succeeded and, if so,
-     * dispatches PaymentConfirmed (see PaymentDriver's docblock) rather
-     * than placing the order itself or returning it here. This method is
-     * fire-and-forget as far as the Order is concerned: a caller that
-     * needs it back listens for OrderPlaced, the same way a driver's own
-     * post-placement step does — see PaymentConfirmed's docblock for why a
-     * direct return value doesn't fit every gateway (async/webhook-driven
-     * confirmations have no synchronous caller waiting for one at all).
+     * The one storefront-facing "place this order and pay for it" call —
+     * the point where Checkout hands off to Payment. Ensures a draft
+     * Order exists (Cart::createOrder() — confirmed idempotent against a
+     * cart's own pre-existing, not-yet-placed-at draft; see
+     * vendor/lunarphp/core/src/Actions/Carts/CreateOrder.php), then
+     * resolves the payment type selected by selectPaymentMethod() and
+     * calls pay() or authorize() on its driver, per that type's
+     * config('lunar.payments.types.{type}.capture_mode') — boboko-core's
+     * own types (config/payment.php) are merged into that same Lunar
+     * config key by PaymentServiceProvider::boot().
      *
-     * $data carries whatever that driver needs (Stripe's payment_intent
-     * id, a future redirect-based provider's callback payload).
+     * Returns the driver's own PaymentResult UNCHANGED — this method does
+     * not wait for or resolve anything past what pay()/authorize() itself
+     * returns synchronously. A Pending result (an async gateway like
+     * Stripe requiring 3-D Secure/a redirect) is a normal, expected
+     * outcome, not an error — the caller (a storefront controller) is
+     * responsible for whatever the gateway needs next.
      *
-     * The fingerprint passed to the driver is the one captured by
-     * selectPaymentMethod(), not supplied by the caller — see that
-     * method's docblock. Throws the same FingerprintMismatchException a
-     * caller-supplied one would if the cart's total has since changed;
-     * missing entirely (selectPaymentMethod() was never called for this
-     * cart) is treated the same as a mismatch, not a different error.
+     * KNOWN GAP, explicitly out of scope for now: PaymentResult alone does
+     * not carry gateway-specific continuation data (e.g. Stripe's
+     * PaymentIntent client_secret for a Pending result needing frontend
+     * confirmation) — that concept existed on the deleted PaymentInitiation
+     * DTO and was intentionally removed from Payment's abstraction layer.
+     * Nothing here re-introduces it; only OfflinePaymentDriver's
+     * always-Immediate-Succeeded path is fully wired end-to-end today.
      *
-     * @param  array<string, mixed>  $data
+     * The draft order's own $order->total (not the Cart's) is what gets
+     * passed as $amount — Order::$total is Lunar's own Price-cast
+     * attribute, already resolving the correct Currency via the order's
+     * own currency_code, and is the authoritative total once the draft
+     * row exists.
      *
-     * @throws UnknownPaymentTypeException if $type isn't currently offered
-     *   (see getPaymentMethods()) — re-checked here, not just in
-     *   selectPaymentMethod(), since a type could be disabled between
-     *   selection and confirmation
-     * @throws \Lunar\Exceptions\FingerprintMismatchException
-     * @throws \Lunar\Exceptions\Carts\CartException
+     * $context passed to the driver is {cart_id, order_id} — the exact
+     * keys Modules\Core\Payment\Drivers\StripePaymentDriver::
+     * rememberIntent() already reads.
+     *
+     * Same fingerprint precondition the old placeOrder() had: mandatory,
+     * not optional, checked before the draft is created.
+     *
+     * @param  array<string, mixed>  $data  passed through untouched to
+     *   the driver's pay()/authorize() — e.g. Stripe's payment_method
+     *   token.
+     *
+     * @throws UnknownPaymentTypeException if the cart's selected
+     *   payment_method (from selectPaymentMethod()) is no longer offered
+     *   — re-checked here, not just at selection time, since a type could
+     *   be disabled in between
+     * @throws FingerprintMismatchException
+     * @throws CartException
      */
-    public function confirmPayment(string $type, array $data = []): void
+    public function initiatePayment(string $fingerprint, array $data = []): PaymentResult
     {
-        if (! in_array($type, $this->getPaymentMethods(), true)) {
-            throw new UnknownPaymentTypeException($type);
+        $cart = $this->cart->currentOrCreate();
+        $cart->checkFingerprint($fingerprint);
+
+        $type = $cart->meta['payment_method'] ?? null;
+
+        if ($type === null || ! in_array($type, $this->getPaymentMethods(), true)) {
+            throw new UnknownPaymentTypeException((string) $type);
         }
 
-        $cart = $this->cart->currentOrCreate();
-        $fingerprint = $cart->meta['checkout_fingerprint'] ?? '';
+        $order = $cart->createOrder();
 
-        $this->paymentDrivers->resolve($type)->confirm($cart, $type, $fingerprint, $data);
+        $driver = $this->paymentDrivers->resolve($type);
+        $captureMode = config("lunar.payments.types.{$type}.capture_mode", 'pay');
+
+        $context = ['cart_id' => $cart->id, 'order_id' => $order->id];
+
+        return $captureMode === 'authorize'
+            ? $driver->authorize($type, $order->total, $data, $context)
+            : $driver->pay($type, $order->total, $data, $context);
     }
 }

src/Order/Listeners/ApplyResolvedPaymentStatus.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Modules\Core\Order\Listeners;
+
+use Illuminate\Support\Facades\Event;
+use Lunar\Models\Order;
+use Modules\Core\Checkout\Events\OrderPlaced;
+use Modules\Core\Payment\Events\PaymentAuthorized;
+use Modules\Core\Payment\Events\PaymentCaptured;
+
+/**
+ * The only place an Order's status column is written in reaction to a
+ * payment outcome. Registered against BOTH PaymentCaptured and
+ * PaymentAuthorized (see OrderServiceProvider) — same handler either way,
+ * since both carry the same {type, result, context} shape and only differ
+ * in which config key decides the resulting status.
+ *
+ * Reads $event->context['order_id'] to find which Order this outcome
+ * belongs to — Payment has no concept of an Order, so this is the one
+ * place that context key gets consumed on the Order side (Payment's own
+ * StripePaymentDriver reads $context['order_id'] independently, for its
+ * own unrelated correlation need — see that class's rememberIntent()).
+ *
+ * Loads and saves the model (not a bulk ::whereKey()->update()) so
+ * Order::observe()'s updated() hook fires and OrderStatusUpdated goes out
+ * the same as any other status write — see that event's own docblock for
+ * why it's meant to fire "regardless of what wrote it."
+ *
+ * Dispatches Checkout\Events\OrderPlaced itself, once placed_at is set —
+ * see that event's own docblock for why this, not CheckoutService, is now
+ * the dispatch point.
+ */
+class ApplyResolvedPaymentStatus
+{
+    public function handle(PaymentCaptured|PaymentAuthorized $event): void
+    {
+        $orderId = $event->context['order_id'] ?? null;
+
+        if ($orderId === null) {
+            return;
+        }
+
+        $order = Order::findOrFail($orderId);
+
+        $configKey = $event instanceof PaymentCaptured ? 'captured_status' : 'authorized_status';
+        $status = config("lunar.payments.types.{$event->type}.{$configKey}");
+
+        if ($status === null) {
+            return;
+        }
+
+        $wasPlaced = ! blank($order->placed_at);
+
+        $order->update([
+            'status' => $status,
+            'placed_at' => $order->placed_at ?? now(),
+        ]);
+
+        if (! $wasPlaced) {
+            Event::dispatch(new OrderPlaced($order));
+        }
+    }
+}

src/Payment/Contracts/Configurable.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Modules\Core\Payment\Contracts;
+
+/**
+ * Every driver implements this, orthogonal to which payment operations
+ * (SupportsPay, SupportsAuthorization, ...) it supports — whether a driver
+ * can actually be used right now is a separate question from what it's
+ * capable of when it can be. An offline driver has no external dependency
+ * to be missing and always returns true; a gateway driver checks its own
+ * credentials/API key.
+ */
+interface Configurable
+{
+    /**
+     * Independent of any admin-facing enabled/disabled toggle a caller
+     * might also apply on top — this is only about whether the driver
+     * itself is usable right now (e.g. Stripe with no API key configured
+     * is never usable, regardless of any such toggle).
+     */
+    public function isConfigured(): bool;
+}

src/Payment/Contracts/HandlesPaymentCallback.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Modules\Core\Payment\Contracts;
+
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * The async counterpart to SupportsPay::pay()/SupportsAuthorization::
+ * authorize() — implemented only by a driver whose gateway can't resolve
+ * one of those synchronously (a redirect the shopper completes elsewhere,
+ * a webhook that arrives later). A driver whose pay()/authorize() always
+ * returns a terminal PaymentResult (Succeeded/Failed) in the same call
+ * never implements this — there is nothing left to call back.
+ *
+ * Resolves into the SAME events the original pay()/authorize() call would
+ * have produced had it resolved synchronously — PaymentCaptured/
+ * PaymentCaptureFailed for a pending pay(), PaymentAuthorized/
+ * PaymentAuthorizationFailed for a pending authorize(). Which pair
+ * applies is up to the driver to track (e.g. against whatever it stored
+ * when the original call returned Pending), not something this method's
+ * signature can express generically.
+ */
+interface HandlesPaymentCallback
+{
+    /**
+     * $reference is the gateway's own identifier for the pending attempt
+     * (the same value the original pay()/authorize() call returned via
+     * PaymentResult::$reference) — how the driver finds which attempt
+     * this callback belongs to.
+     *
+     * $data carries whatever the callback/webhook payload contains
+     * (Stripe: ['payment_intent' => $id], a redirect-based provider: its
+     * query params or POST body) — passed explicitly by the caller rather
+     * than the driver reaching into the global request(), so this works
+     * the same whether it's called from a synchronous HTTP request or an
+     * async webhook job with no active request at all.
+     *
+     * $context is opaque to the driver, carried through untouched into
+     * whichever Payment event this callback produces — see SupportsPay::
+     * pay()'s own $context param for the full reasoning. A driver that
+     * needs the ORIGINAL context from the pay()/authorize() call (a
+     * webhook's own payload carries none of its own) must have persisted
+     * it itself when that call returned Pending — Payment provides no
+     * storage for this.
+     *
+     * @param  array<string, mixed>  $data
+     * @param  array<string, mixed>  $context
+     */
+    public function handleCallback(string $reference, array $data, array $context = []): PaymentResult;
+}

src/Payment/Contracts/InitiatesPayment.php

@@ -1,54 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\Contracts;
-
-use Modules\Core\Payment\DataTransferObjects\PaymentInitiation;
-
-/**
- * The synchronous half of a payment driver — every driver implements this,
- * since every provider has some notion of "start a payment," even if (like
- * an offline/cash type) there's no real gateway round-trip involved.
- *
- * This is deliberately synchronous, unlike the rest of the payment
- * lifecycle: a storefront request needing a redirect URL, or frontend JS
- * needing a client secret to render an embedded payment form, has nothing
- * to redirect to or render until initiate() returns — there is no event
- * that can hand a mid-request controller a value it needs for its own HTTP
- * response. Everything after this point (the payment actually completing,
- * failing, a chargeback) is genuinely async and belongs on
- * HandlesPaymentCallback / PaymentSucceeded / PaymentFailed instead.
- */
-interface InitiatesPayment
-{
-    /**
-     * Whether this driver can actually be used right now — e.g. checking
-     * an API key is configured. Independent of
-     * Modules\Core\Payment\Models\PaymentMethod::enabled (the admin
-     * on/off toggle).
-     */
-    public function isConfigured(): bool;
-
-    /**
-     * $type is the payment type key being initiated (e.g.
-     * 'cash-on-delivery', 'viva', 'stripe') — passed through even though
-     * most drivers only ever serve one type, because a driver shared
-     * across several types needs it to look up that type's own config.
-     *
-     * $data carries whatever the gateway needs to start this payment
-     * (amount, currency, return/webhook URLs, customer details) — the
-     * caller's responsibility to assemble, since a driver has no notion
-     * of a cart or order to pull them from itself.
-     *
-     * $context is opaque to the driver (see PaymentDriver — actually
-     * PaymentSucceeded's docblock — for the full reasoning): carried
-     * through untouched into whatever PaymentSucceeded/PaymentFailed this
-     * payment eventually produces, so the caller can correlate the result
-     * back to whatever it needs (a cart id and fingerprint, for
-     * Checkout), without this driver or Payment generally needing to know
-     * what that is.
-     *
-     * @param  array<string, mixed>  $data
-     * @param  array<string, mixed>  $context
-     */
-    public function initiate(string $type, array $data, array $context = []): PaymentInitiation;
-}

src/Payment/Contracts/PaymentDriver.php

@@ -1,65 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\Contracts;
-
-use Lunar\Exceptions\FingerprintMismatchException;
-use Lunar\Exceptions\Carts\CartException;
-use Lunar\Models\Cart;
-
-/**
- * A boboko-owned payment driver — wraps a payment gateway's own confirmation
- * mechanics (Stripe's synchronous authorize() call, a redirect-based
- * provider's async callback/webhook, anything else) behind one uniform
- * moment: "payment is confirmed."
- *
- * confirm() is the only thing a driver is required to do: once it has,
- * by whatever mechanism is native to that gateway, independently decided
- * the payment succeeded, it dispatches Modules\Core\Checkout\Events\
- * PaymentConfirmed — no driver ever calls CheckoutService::placeOrder() or
- * Lunar\Models\Cart::createOrder() directly. CheckoutService itself listens
- * for PaymentConfirmed and places the order from there; a driver that needs
- * to do something to the placed Order afterward (status mapping, syncing
- * gateway state) listens for the resulting OrderPlaced itself, matching it
- * via $order->meta['payment_method'] — see PaymentConfirmed's docblock for
- * why. This split is what makes an async/webhook-driven gateway (payment
- * confirmed in a request that has no synchronous caller waiting for an
- * Order at all) and a synchronous one (Stripe) work through the exact same
- * contract. See docs/checkout.md / docs/payments.md.
- */
-interface PaymentDriver
-{
-    /**
-     * Whether this driver can actually be used right now — e.g. Stripe
-     * checking its own API key is present, an offline-style driver always
-     * returning true since it has no external dependency. Independent of
-     * Modules\Core\Payment\Models\PaymentMethod::enabled (the admin
-     * on/off toggle) — CheckoutService::getPaymentMethods() combines both:
-     * a type is only offered to the storefront if it's administratively
-     * enabled AND its driver reports itself configured.
-     */
-    public function isConfigured(): bool;
-
-    /**
-     * $type is the payment type key being confirmed (e.g. 'cash-in-hand',
-     * 'cash-on-delivery', 'stripe') — passed through even though most
-     * drivers only ever serve one type, because a driver shared across
-     * several types (e.g. one "no real confirmation" offline driver behind
-     * both cash-in-hand and cash-on-delivery) needs it to look up that
-     * type's own config (e.g. its 'authorized' status) rather than another
-     * type's.
-     *
-     * $data carries whatever the gateway needs to confirm this specific
-     * payment (Stripe: ['payment_intent' => $id], a redirect-based
-     * provider: its callback payload) — passed explicitly by the caller
-     * (a controller, a webhook job) rather than a driver reaching into the
-     * global request(), so confirm() works the same whether it's called
-     * from a synchronous HTTP request or an async webhook/job with no
-     * active request at all.
-     *
-     * @param  array<string, mixed>  $data
-     *
-     * @throws FingerprintMismatchException
-     * @throws CartException
-     */
-    public function confirm(Cart $cart, string $type, string $fingerprint, array $data): void;
-}

src/Payment/Contracts/SupportsAuthorization.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Modules\Core\Payment\Contracts;
+
+use Lunar\DataTypes\Price;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * A driver's hold-only operation (Mastercard's "Authorize", Nexi's
+ * ActionType::PREAUTH(), Stripe's capture_method=manual) — places a hold
+ * on the customer's payment method without moving any funds. Only a
+ * driver that also implements SupportsCaptures/SupportsVoids can do
+ * anything with the resulting hold afterward; implementing this alone
+ * with neither of those would leave the hold to simply expire
+ * (typically ~7 days, gateway-dependent) with no way to settle or release
+ * it early.
+ *
+ * A driver capable of both authorize-then-settle AND an atomic charge
+ * (most card gateways) implements this alongside SupportsPay — which one
+ * gets called for a given payment attempt is the CALLER's choice (a
+ * policy decision), not something this driver decides for itself.
+ *
+ * Dispatches Modules\Core\Payment\Events\PaymentAuthorized or
+ * PaymentAuthorizationFailed based on the returned PaymentResult's status,
+ * unless $result->status is Pending — see SupportsPay's docblock for the
+ * same async-resolution note.
+ */
+interface SupportsAuthorization
+{
+    /**
+     * Same $type/$amount/$data/$context reasoning as SupportsPay::pay().
+     *
+     * @param  array<string, mixed>  $data
+     * @param  array<string, mixed>  $context
+     */
+    public function authorize(string $type, Price $amount, array $data = [], array $context = []): PaymentResult;
+}

src/Payment/Contracts/SupportsCaptures.php

@@ -2,22 +2,38 @@
 
 namespace Modules\Core\Payment\Contracts;
 
-use Lunar\Models\Order;
-use Modules\Core\Payment\DataTransferObjects\CaptureResult;
+use Lunar\DataTypes\Price;
+use Modules\Core\Payment\DTOs\PaymentResult;
 
 /**
- * Optional capability for payment drivers whose gateway supports a
- * separate authorize-then-capture step. Many redirect/wallet-style
- * gateways (Viva Wallet included, for most flows) charge in full at
- * checkout and never need this — SupportsRefunds is the one they're more
- * likely to implement instead.
+ * Settles a PRIOR SupportsAuthorization::authorize() hold — only ever
+ * valid against a reference that call (or a HandlesPaymentCallback
+ * resolving it) produced, never called standalone. A driver with no
+ * authorize-then-settle model at all (most redirect/wallet gateways, any
+ * offline driver) never implements this — it settles everything through
+ * SupportsPay::pay() in one step instead.
+ *
+ * Dispatches Modules\Core\Payment\Events\PaymentCaptured or
+ * PaymentCaptureFailed — the same terminal events SupportsPay::pay()
+ * produces, since "money has been captured" is the same business fact
+ * regardless of which path reached it.
  */
 interface SupportsCaptures
 {
     /**
-     * $reference is the gateway's own identifier for the authorized charge
-     * — see SupportsRefunds::refund() for why this isn't a Lunar
-     * Transaction. $amount is in the currency's minor unit.
+     * $reference is the identifier SupportsAuthorization::authorize()
+     * returned (PaymentResult::$reference) for the hold being settled.
+     *
+     * $amount is Lunar's own Price (never a gateway's own minor-unit
+     * scale — see PaymentResult's docblock), and lets a driver capture
+     * less than the full authorized amount (e.g. shipping less than
+     * ordered) — up to the driver/gateway whether a partial capture also
+     * releases the remainder or leaves it capturable again later
+     * (multicapture-style gateways). Required explicitly, not derived by
+     * the driver from a live gateway lookup — the caller (whatever placed
+     * the original authorize() call) already knows it.
+     *
+     * @param  array<string, mixed>  $context
      */
-    public function capture(Order $order, string $reference, int $amount, ?string $notes = null): CaptureResult;
+    public function capture(string $reference, Price $amount, array $context = []): PaymentResult;
 }

src/Payment/Contracts/SupportsPay.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Modules\Core\Payment\Contracts;
+
+use Lunar\DataTypes\Price;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * A driver's atomic charge — authorize and capture in one gateway call
+ * (Mastercard's own "Pay" operation, Nexi's ActionType::PAY(), Stripe's
+ * capture_method=automatic, or an offline driver with no gateway at all).
+ * Distinct from SupportsAuthorization: a driver that only ever settles in
+ * one step implements this and nothing else — there is no separate hold
+ * to later capture() or void().
+ *
+ * Dispatches Modules\Core\Payment\Events\PaymentCaptured or
+ * PaymentCaptureFailed based on the returned PaymentResult's status,
+ * unless $result->status is Pending (an async gateway that hasn't
+ * resolved yet — see HandlesPaymentCallback for how that gets resolved
+ * later, from a separate call this method's return value does not wait
+ * on).
+ */
+interface SupportsPay
+{
+    /**
+     * $type is the payment type key being charged (e.g. 'cash-on-delivery',
+     * 'stripe') — passed through even though most drivers only ever serve
+     * one type, because a driver shared across several types needs it to
+     * look up that type's own config.
+     *
+     * $amount is required, not optional data a caller might omit — there
+     * is no way to process a payment without knowing what to charge.
+     * Lunar's own Price (bundling its own currency) — the same money
+     * representation every other Payment contract method takes/returns,
+     * see PaymentResult's own docblock.
+     *
+     * $data carries whatever ELSE the gateway needs (customer details, a
+     * payment method token) — the caller's responsibility to assemble,
+     * since a driver has no notion of a cart or order to pull them from
+     * itself.
+     *
+     * $context is opaque to the driver — carried through untouched into
+     * whichever Payment event this call (or a later handleCallback()
+     * resolving it) produces, so the caller can correlate the result back
+     * to whatever it needs, without Payment ever needing to know what
+     * that is.
+     *
+     * @param  array<string, mixed>  $data
+     * @param  array<string, mixed>  $context
+     */
+    public function pay(string $type, Price $amount, array $data = [], array $context = []): PaymentResult;
+}

src/Payment/Contracts/SupportsRefunds.php

@@ -2,23 +2,34 @@
 
 namespace Modules\Core\Payment\Contracts;
 
-use Lunar\Models\Order;
-use Modules\Core\Payment\DataTransferObjects\RefundResult;
+use Lunar\DataTypes\Price;
+use Modules\Core\Payment\DTOs\PaymentResult;
 
 /**
- * Optional capability for payment drivers whose gateway supports refunding
- * a prior charge. Drivers without a refund API (or that never got that far
- * — e.g. an offline/manual driver) simply don't implement it. Mirrors
- * Shipping\Contracts\SupportsTracking's opt-in shape.
+ * Reverses settled funds — independent of SupportsCaptures/SupportsVoids:
+ * a driver that only ever settles via SupportsPay::pay() (no separate
+ * authorize step) can still implement this, since a refund targets money
+ * already taken regardless of how it got taken. A driver implements this
+ * whenever its gateway exposes any refund capability at all, whether or
+ * not it also supports authorize-then-capture.
+ *
+ * Dispatches Modules\Core\Payment\Events\PaymentRefunded or
+ * PaymentRefundFailed.
  */
 interface SupportsRefunds
 {
     /**
-     * $reference is the gateway's own identifier for the charge being
-     * refunded (e.g. a Viva Wallet transaction id) — not a Lunar
-     * Transaction model, since not every gateway's refund flow maps
-     * cleanly onto one. $amount is in the currency's minor unit, same
-     * convention as Lunar\Base\Casts\Price.
+     * $reference is the identifier the original SupportsPay::pay() or
+     * SupportsCaptures::capture() call returned for the settled funds
+     * being refunded.
+     *
+     * $amount is Lunar's own Price (never a gateway's own minor-unit
+     * scale — see PaymentResult's docblock), allowing a partial refund; a
+     * gateway may allow multiple partial refunds against one settlement,
+     * up to its own total. Required explicitly, same reasoning as
+     * SupportsCaptures::capture()'s own $amount.
+     *
+     * @param  array<string, mixed>  $context
      */
-    public function refund(Order $order, string $reference, int $amount, ?string $notes = null): RefundResult;
+    public function refund(string $reference, Price $amount, array $context = []): PaymentResult;
 }

src/Payment/Contracts/SupportsVoids.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Modules\Core\Payment\Contracts;
+
+use Lunar\DataTypes\Price;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * Cancels a PRIOR SupportsAuthorization::authorize() hold WITHOUT
+ * settling it — the "actually, never mind" exit SupportsCaptures::capture()
+ * doesn't take. No funds ever moved, so this is not a refund: there is
+ * nothing to give back, only a hold to release early (rather than letting
+ * it simply expire on its own).
+ *
+ * Dispatches Modules\Core\Payment\Events\PaymentVoided or
+ * PaymentVoidFailed.
+ */
+interface SupportsVoids
+{
+    /**
+     * $reference is the identifier SupportsAuthorization::authorize()
+     * returned for the hold being released.
+     *
+     * $amount is the authorized amount being released — Lunar's own
+     * Price, same as every other Payment contract method (see
+     * PaymentResult's own docblock). Required explicitly: the caller
+     * (whatever placed the original authorize() call) already knows it,
+     * same reasoning as SupportsCaptures::capture()'s own $amount — a
+     * driver shouldn't need a live gateway lookup just to know what it's
+     * releasing.
+     *
+     * @param  array<string, mixed>  $context
+     */
+    public function void(string $reference, Price $amount, array $context = []): PaymentResult;
+}

src/Payment/DTOs/PaymentContinuation.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Modules\Core\Payment\DTOs;
+
+use Modules\Core\Payment\Enums\PaymentContinuationType;
+
+/**
+ * What a caller does next with a Pending PaymentResult, gateway-agnostic —
+ * see PaymentContinuationType for the two shapes. Deliberately minimal:
+ * this is NOT a return to the deleted PaymentInitiation DTO (which also
+ * carried mode/reference/meta) — reference already lives on PaymentResult
+ * itself, and mode is now this DTO's own $type.
+ */
+final class PaymentContinuation
+{
+    public function __construct(
+        public readonly PaymentContinuationType $type,
+        public readonly string $value,
+    ) {}
+}

src/Payment/DTOs/PaymentResult.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Modules\Core\Payment\DTOs;
+
+use Lunar\DataTypes\Price;
+use Modules\Core\Payment\Enums\PaymentResultStatus;
+
+/**
+ * The one shape every Payment operation (pay, authorize, capture, void,
+ * refund, handleCallback) returns, regardless of driver — a caller never
+ * writes gateway-specific branching to read the outcome.
+ *
+ * Deliberately not one-size-fits-all in richness underneath: a gateway's
+ * own response can be as sparse as Nexi's capture (just an operation id +
+ * timestamp, no echoed amount or status) or as rich as Stripe's
+ * PaymentIntent (status, amounts, decline classification, full error
+ * detail). $status/$reference/$amount are the only fields every driver can
+ * always populate — $amount from what WE requested, not necessarily
+ * echoed by the gateway. Everything else is best-effort normalization;
+ * $raw is the unconditional escape hatch for genuine audit fidelity
+ * (the untouched gateway response), so nothing is ever lost even when a
+ * gateway has no field to normalize into $failureReason/$retriable.
+ */
+final class PaymentResult
+{
+    /**
+     * @param  $amount  Lunar's own money type (Lunar\DataTypes\Price —
+     *   integer minor units bundled with its Currency), the SAME
+     *   representation every contract method takes/returns — never a
+     *   gateway's own minor-unit scale. Each driver converts at its own
+     *   boundary (e.g. StripeManager::toStripeAmount()/fromStripeAmount())
+     *   before calling out to, or after reading back from, its gateway —
+     *   Payment itself only ever speaks Lunar's Price.
+     * @param  $failureReason  a human-readable reason, only meaningful
+     *   when $status is Failed — the driver's own normalization of
+     *   whatever the gateway called it (Stripe's decline_code message,
+     *   Nexi's ErrorsInner::$description, ...).
+     * @param  $retriable  whether the caller should offer "try again" with
+     *   the SAME payment method, vs. "use a different one" — real,
+     *   gateway-native distinction on Stripe (decline_code soft/hard) and
+     *   Mastercard (merchantAdviceCode / scheme soft-decline codes), but
+     *   Nexi's OperationResult has no such signal at all. Defaults to
+     *   false (assume not safely retriable) rather than guessing when a
+     *   driver's gateway has no such classification.
+     * @param  $raw  the untouched gateway response body — always
+     *   populated, even when the gateway's own fields were too sparse to
+     *   normalize into anything above.
+     * @param  $meta  driver-specific extras that don't fit the normalized
+     *   fields above (e.g. a card's last four digits).
+     * @param  $continuation  only meaningful when $status is Pending —
+     *   what the caller does next (a redirect URL, a client secret for
+     *   frontend JS), gateway-agnostic. Null for every other status, and
+     *   for any driver whose pay()/authorize() never returns Pending
+     *   (e.g. OfflinePaymentDriver).
+     */
+    public function __construct(
+        public readonly PaymentResultStatus $status,
+        public readonly string $reference,
+        public readonly Price $amount,
+        public readonly ?string $failureReason = null,
+        public readonly bool $retriable = false,
+        public readonly array $raw = [],
+        public readonly array $meta = [],
+        public readonly ?PaymentContinuation $continuation = null,
+    ) {}
+}

src/Payment/DataTransferObjects/CaptureResult.php

@@ -1,18 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\DataTransferObjects;
-
-/**
- * Returned by SupportsCaptures::capture() — see RefundResult for why this
- * carries nothing Lunar-shaped.
- */
-class CaptureResult
-{
-    public function __construct(
-        public readonly bool $success,
-        public readonly int $amount,
-        public readonly ?string $reference = null,
-        public readonly ?string $message = null,
-        public readonly array $meta = [],
-    ) {}
-}

src/Payment/DataTransferObjects/PaymentInitiation.php

@@ -1,31 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\DataTransferObjects;
-
-use Modules\Core\Payment\Enums\PaymentInitiationMode;
-
-/**
- * Returned by InitiatesPayment::initiate() — the one thing a caller needs
- * synchronously, in the same request, regardless of which provider is
- * behind it. redirectUrl/clientSecret are mutually exclusive in practice
- * (only the one matching $mode is ever set) but both nullable rather than
- * split into per-mode subclasses — see PaymentInitiationMode for why.
- *
- * $reference is the gateway's own identifier for this payment attempt
- * (an order/session/intent id) — the same value HandlesPaymentCallback's
- * driver will later see again in the callback payload, and what
- * PaymentSucceeded/PaymentFailed carry forward. A driver in Immediate
- * mode still returns one, even though there's no callback to correlate
- * against, since it's also what gets recorded as the Transaction's
- * reference.
- */
-class PaymentInitiation
-{
-    public function __construct(
-        public readonly PaymentInitiationMode $mode,
-        public readonly string $reference,
-        public readonly ?string $redirectUrl = null,
-        public readonly ?string $clientSecret = null,
-        public readonly array $meta = [],
-    ) {}
-}

src/Payment/DataTransferObjects/RefundResult.php

@@ -1,20 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\DataTransferObjects;
-
-/**
- * Returned by SupportsRefunds::refund() — gateway-agnostic, carries nothing
- * Lunar-shaped (no Transaction, no Lunar DTO). TransactionRecorder turns
- * this into a Transaction row afterward; the driver itself never writes
- * one.
- */
-class RefundResult
-{
-    public function __construct(
-        public readonly bool $success,
-        public readonly int $amount,
-        public readonly ?string $reference = null,
-        public readonly ?string $message = null,
-        public readonly array $meta = [],
-    ) {}
-}

src/Payment/Drivers/OfflinePaymentDriver.php

@@ -2,27 +2,27 @@
 
 namespace Modules\Core\Payment\Drivers;
 
-use Lunar\Models\Cart;
-use Modules\Core\Checkout\Events\OrderPlaced;
-use Modules\Core\Checkout\Events\PaymentConfirmed;
-use Modules\Core\Payment\Contracts\PaymentDriver;
+use Illuminate\Support\Str;
+use Lunar\DataTypes\Price;
+use Modules\Core\Payment\Contracts\Configurable;
+use Modules\Core\Payment\Contracts\SupportsPay;
+use Modules\Core\Payment\DTOs\PaymentResult;
+use Modules\Core\Payment\Enums\PaymentResultStatus;
+use Modules\Core\Payment\Events\PaymentCaptured;
 
 /**
  * Shared by every payment type with no real gateway to confirm against —
  * cash-in-hand, cash-on-delivery — where the shopper pays at pickup/on
- * delivery, not at checkout. confirm() has nothing to wait on, so it
- * dispatches PaymentConfirmed immediately, same moment Lunar's own
- * OfflinePayment would place the order — but the actual placement now
- * happens in CheckoutService::onPaymentConfirmed(), not here. $data is
- * unused: nothing about this confirmation depends on gateway-specific
- * payload.
+ * delivery, not at checkout. There is no separate hold-then-settle model
+ * (SupportsAuthorization/SupportsCaptures/SupportsVoids) and no async
+ * resolution (HandlesPaymentCallback) — pay() decides success immediately
+ * and dispatches PaymentCaptured before returning.
  *
- * The status-mapping step this driver used to do inline right after
- * placeOrder() returned now happens in onOrderPlaced() below instead —
- * see PaymentDriver's docblock for why a driver can no longer rely on
- * placeOrder()'s return value.
+ * $reference is generated here (not supplied by a gateway, since there is
+ * none) purely so PaymentCaptured, and anything downstream keying on it,
+ * have something to identify this attempt by.
  */
-class OfflinePaymentDriver implements PaymentDriver
+class OfflinePaymentDriver implements Configurable, SupportsPay
 {
     /**
      * Always true — no external dependency to be missing.
@@ -32,30 +32,18 @@ class OfflinePaymentDriver implements PaymentDriver
         return true;
     }
 
-    public function confirm(Cart $cart, string $type, string $fingerprint, array $data): void
+    public function pay(string $type, Price $amount, array $data = [], array $context = []): PaymentResult
     {
-        PaymentConfirmed::dispatch($cart, $type, $fingerprint, $data);
-    }
+        $reference = 'offline-'.Str::uuid();
 
-    /**
-     * Registered in PaymentServiceProvider. Every offline-style type
-     * shares this one driver, so $order->meta['payment_method'] is checked
-     * against config('lunar.payments.types') to confirm the placed order
-     * actually belongs to one of them, rather than assuming every
-     * OrderPlaced is this driver's to act on — a Stripe order placed via
-     * StripePaymentDriver fires the same event.
-     */
-    public function onOrderPlaced(OrderPlaced $event): void
-    {
-        $order = $event->order;
-        $type = $order->meta['payment_method'] ?? null;
+        $result = new PaymentResult(
+            status: PaymentResultStatus::Succeeded,
+            reference: $reference,
+            amount: $amount,
+        );
 
-        if (! $type || config("lunar.payments.types.{$type}.payment_driver") !== self::class) {
-            return;
-        }
+        PaymentCaptured::dispatch($type, $result, $context);
 
-        $order->update([
-            'status' => config("lunar.payments.types.{$type}.authorized", $order->status),
-        ]);
+        return $result;
     }
 }

src/Payment/Drivers/StripePaymentDriver.php

@@ -2,44 +2,69 @@
 
 namespace Modules\Core\Payment\Drivers;
 
-use Lunar\Models\Cart;
-use Lunar\Stripe\Actions\UpdateOrderFromIntent;
+use Lunar\DataTypes\Price;
+use Lunar\Models\Currency;
 use Lunar\Stripe\Facades\Stripe;
+use Lunar\Stripe\Managers\StripeManager;
 use Lunar\Stripe\Models\StripePaymentIntent;
-use Modules\Core\Checkout\Events\OrderPlaced;
-use Modules\Core\Checkout\Events\PaymentConfirmed;
-use Modules\Core\Payment\Contracts\PaymentDriver;
-use Modules\Core\Payment\Exceptions\PaymentNotConfirmedException;
+use Modules\Core\Payment\Contracts\Configurable;
+use Modules\Core\Payment\Contracts\HandlesPaymentCallback;
+use Modules\Core\Payment\Contracts\SupportsAuthorization;
+use Modules\Core\Payment\Contracts\SupportsCaptures;
+use Modules\Core\Payment\Contracts\SupportsPay;
+use Modules\Core\Payment\Contracts\SupportsRefunds;
+use Modules\Core\Payment\Contracts\SupportsVoids;
+use Modules\Core\Payment\DTOs\PaymentContinuation;
+use Modules\Core\Payment\DTOs\PaymentResult;
+use Modules\Core\Payment\Enums\PaymentContinuationType;
+use Modules\Core\Payment\Enums\PaymentResultStatus;
+use Modules\Core\Payment\Events\PaymentAuthorizationFailed;
+use Modules\Core\Payment\Events\PaymentAuthorized;
+use Modules\Core\Payment\Events\PaymentCaptureFailed;
+use Modules\Core\Payment\Events\PaymentCaptured;
+use Modules\Core\Payment\Events\PaymentRefundFailed;
+use Modules\Core\Payment\Events\PaymentRefunded;
+use Modules\Core\Payment\Events\PaymentVoidFailed;
+use Modules\Core\Payment\Events\PaymentVoided;
+use Stripe\Exception\ApiErrorException;
 use Stripe\PaymentIntent;
 
 /**
- * Wraps Lunar\Stripe\StripePaymentType::authorize() to satisfy
- * Modules\Core\Payment\Contracts\PaymentDriver — dispatches
- * PaymentConfirmed at the moment Stripe confirms payment, instead of the
- * vendor's own Cart::createOrder() call.
+ * Talks to Stripe's PaymentIntent API directly — deliberately NOT via
+ * Lunar\Stripe\Facades\Stripe::createIntent()/fetchOrCreateIntent(), which
+ * take a Lunar\Models\Cart and derive amount/currency from it. Payment
+ * must never receive a Cart (see docs/payments.md) — pay()/authorize()
+ * already receive $amount explicitly as their own required Lunar Price
+ * parameter (see PaymentResult's own docblock), the caller's job to
+ * assemble, same as every other driver.
  *
- * This is a fork, not a decoration: StripePaymentType::authorize() is
- * `final` and calls Cart::createOrder() directly with no seam to redirect
- * that one call — so this class reimplements authorize()'s logic (intent
- * retrieval, capture-on-policy) rather than wrapping the vendor method.
- * Kept deliberately close to the original so a lunarphp/stripe upgrade is
- * easy to diff against. See docs/payments.md.
+ * Every amount that crosses this class's own boundary is converted right
+ * there: Lunar's Price -> Stripe's minor-unit int going INTO a gateway
+ * call (StripeManager::toStripeAmount()), Stripe's response amount ->
+ * Lunar's Price coming back OUT (StripeManager::fromStripeAmount()).
+ * Nothing outside this class ever sees a Stripe-scaled integer.
  *
- * The status-mapping step (UpdateOrderFromIntent) this driver used to do
- * inline right after placeOrder() returned now happens in onOrderPlaced()
- * below instead — see PaymentDriver's docblock for why a driver can no
- * longer rely on placeOrder()'s return value. Since that step needs the
- * live Stripe PaymentIntent, not just the Order, onOrderPlaced() re-fetches
- * it from Stripe via the StripePaymentIntent row this method already wrote
- * (keyed by the order's cart_id) rather than carrying the PaymentIntent
- * object across the event boundary itself.
+ * Correlating a later handleCallback() (a separate request — a webhook)
+ * back to whatever $context identified this attempt is solved the same
+ * way lunarphp/stripe's own StripePaymentType/ProcessStripeWebhook solve
+ * it: real cart_id/order_id columns on Lunar\Stripe\Models\
+ * StripePaymentIntent (a table already owned by lunarphp/stripe, already
+ * shaped for exactly this), not a generic context blob. See
+ * docs/payments.md "Async resolution" for the full reasoning.
  */
-class StripePaymentDriver implements PaymentDriver
+class StripePaymentDriver implements
+    Configurable,
+    SupportsPay,
+    SupportsAuthorization,
+    SupportsCaptures,
+    SupportsVoids,
+    SupportsRefunds,
+    HandlesPaymentCallback
 {
     /**
      * Same key lunarphp/stripe's own StripeManager reads its API key from
-     * (Stripe::setApiKey(config('services.stripe.key')) in
-     * StripeManager::__construct()) — no key, no usable driver.
+     * (Stripe::setApiKey(config('services.stripe.key'))) — no key, no
+     * usable driver.
      */
     public function isConfigured(): bool
     {
@@ -47,79 +72,312 @@ class StripePaymentDriver implements PaymentDriver
     }
 
     /**
-     * @throws PaymentNotConfirmedException if Stripe hasn't confirmed the
-     *   payment intent (wrong intent id, already processed, or the gateway
-     *   call itself fails) — nothing here should be treated as "confirm
-     *   anyway."
+     * Atomic charge — capture_method: automatic. Stripe still frequently
+     * confirms into requires_action/requires_confirmation rather than
+     * succeeded in the same call (3-D Secure, most real cards) — Pending
+     * is a normal outcome here, not an edge case, resolved later via
+     * handleCallback().
      */
-    public function confirm(Cart $cart, string $type, string $fingerprint, array $data): void
+    public function pay(string $type, Price $amount, array $data = [], array $context = []): PaymentResult
     {
-        $paymentIntentId = $data['payment_intent'];
-
-        $paymentIntentModel = StripePaymentIntent::where('intent_id', $paymentIntentId)->first();
-
-        if ($paymentIntentModel && ! $paymentIntentModel->isActive()) {
-            throw new PaymentNotConfirmedException('Payment intent already processed.');
-        }
-
-        if (! $paymentIntentModel) {
-            $paymentIntentModel = StripePaymentIntent::create([
-                'intent_id' => $paymentIntentId,
-                'cart_id' => $cart->id,
-            ]);
-        }
-
-        $paymentIntentModel->update(['processing_at' => now()]);
-
-        $stripe = Stripe::getClient();
-        $paymentIntent = $stripe->paymentIntents->retrieve($paymentIntentId);
-
-        if (! $paymentIntent) {
-            throw new PaymentNotConfirmedException('Unable to locate payment intent.');
-        }
-
-        $policy = config('lunar.stripe.policy', 'automatic');
-
-        if ($paymentIntent->status === PaymentIntent::STATUS_REQUIRES_CAPTURE && $policy === 'automatic') {
-            $paymentIntent = $stripe->paymentIntents->capture($paymentIntentId);
-        }
-
-        if ($paymentIntent->status !== PaymentIntent::STATUS_SUCCEEDED) {
-            $paymentIntentModel->update(['status' => $paymentIntent->status]);
-
-            throw new PaymentNotConfirmedException(
-                $paymentIntent->last_payment_error->message ?? "Payment intent status: {$paymentIntent->status}."
-            );
-        }
-
-        $paymentIntentModel->status = $paymentIntent->status;
-        $paymentIntentModel->save();
-
-        PaymentConfirmed::dispatch($cart, $type, $fingerprint, $data);
+        return $this->createAndConfirm($type, $amount, $data, $context, captureMethod: 'automatic');
     }
 
     /**
-     * Registered in PaymentServiceProvider. Matches via the order's
-     * cart_id against the StripePaymentIntent row confirm() wrote, so a
-     * non-Stripe OrderPlaced (offline types fire the same event) is
-     * ignored rather than acted on.
+     * Hold only — capture_method: manual. Resolves to Pending or an
+     * authorized (requires_capture) intent, never succeeded directly:
+     * Stripe never captures on its own for a manual intent.
      */
-    public function onOrderPlaced(OrderPlaced $event): void
+    public function authorize(string $type, Price $amount, array $data = [], array $context = []): PaymentResult
     {
-        $order = $event->order;
+        return $this->createAndConfirm($type, $amount, $data, $context, captureMethod: 'manual');
+    }
 
-        $paymentIntentModel = StripePaymentIntent::where('cart_id', $order->cart_id)->first();
-
-        if (! $paymentIntentModel) {
-            return;
+    private function createAndConfirm(string $type, Price $amount, array $data, array $context, string $captureMethod): PaymentResult
+    {
+        try {
+            $paymentIntent = Stripe::getClient()->paymentIntents->create([
+                'amount' => StripeManager::toStripeAmount($amount->value, $amount->currency),
+                'currency' => $amount->currency->code,
+                'capture_method' => $captureMethod,
+                'confirm' => true,
+                'payment_method' => $data['payment_method'] ?? null,
+                'automatic_payment_methods' => isset($data['payment_method'])
+                    ? null
+                    : ['enabled' => true],
+            ]);
+        } catch (ApiErrorException $e) {
+            return $this->declined($type, $amount, $e, $context, authorizing: $captureMethod === 'manual');
         }
 
-        $paymentIntentModel->order_id = $order->id;
-        $paymentIntentModel->processed_at = now();
-        $paymentIntentModel->save();
+        $this->rememberIntent($paymentIntent, $type, $context);
 
-        $paymentIntent = Stripe::getClient()->paymentIntents->retrieve($paymentIntentModel->intent_id);
+        return $this->resultFromIntent($type, $paymentIntent, $amount, $context, authorizing: $captureMethod === 'manual');
+    }
 
-        UpdateOrderFromIntent::execute($order, $paymentIntent);
+    public function handleCallback(string $reference, array $data, array $context = []): PaymentResult
+    {
+        [$intentModel, $type, $context] = $this->resolveIntentModel($reference, $context, $data['type'] ?? '');
+
+        $paymentIntent = Stripe::getClient()->paymentIntents->retrieve($reference);
+
+        $authorizing = $paymentIntent->capture_method === PaymentIntent::CAPTURE_METHOD_MANUAL;
+
+        if ($paymentIntent->status === PaymentIntent::STATUS_REQUIRES_CAPTURE && ! $authorizing) {
+            // automatic capture_method, but Stripe stopped short of
+            // capturing (rare, but the API contract allows it) — finish
+            // the job pay() started.
+            $paymentIntent = Stripe::getClient()->paymentIntents->capture($reference);
+        }
+
+        $intentModel?->update(['status' => $paymentIntent->status]);
+
+        $amount = $this->priceFromIntent($paymentIntent);
+
+        return $this->resultFromIntent($type, $paymentIntent, $amount, $context, $authorizing);
+    }
+
+    public function capture(string $reference, Price $amount, array $context = []): PaymentResult
+    {
+        [$intentModel, $type, $context] = $this->resolveIntentModel($reference, $context);
+
+        try {
+            $paymentIntent = Stripe::getClient()->paymentIntents->capture($reference, [
+                'amount_to_capture' => StripeManager::toStripeAmount($amount->value, $amount->currency),
+            ]);
+        } catch (ApiErrorException $e) {
+            $result = $this->failure($amount, $e, $reference);
+            PaymentCaptureFailed::dispatch($type, $result, $context);
+
+            return $result;
+        }
+
+        $intentModel?->update(['status' => $paymentIntent->status]);
+
+        $result = new PaymentResult(
+            status: $paymentIntent->status === PaymentIntent::STATUS_SUCCEEDED
+                ? PaymentResultStatus::Succeeded
+                : PaymentResultStatus::Failed,
+            reference: $paymentIntent->id,
+            amount: $amount,
+            raw: $paymentIntent->toArray(),
+        );
+
+        $paymentIntent->status === PaymentIntent::STATUS_SUCCEEDED
+            ? PaymentCaptured::dispatch($type, $result, $context)
+            : PaymentCaptureFailed::dispatch($type, $result, $context);
+
+        return $result;
+    }
+
+    public function void(string $reference, Price $amount, array $context = []): PaymentResult
+    {
+        [$intentModel, $type, $context] = $this->resolveIntentModel($reference, $context);
+
+        try {
+            $paymentIntent = Stripe::getClient()->paymentIntents->cancel($reference);
+        } catch (ApiErrorException $e) {
+            $result = $this->failure($amount, $e, $reference);
+            PaymentVoidFailed::dispatch($type, $result, $context);
+
+            return $result;
+        }
+
+        $intentModel?->update(['status' => $paymentIntent->status]);
+
+        $result = new PaymentResult(
+            status: $paymentIntent->status === PaymentIntent::STATUS_CANCELED
+                ? PaymentResultStatus::Succeeded
+                : PaymentResultStatus::Failed,
+            reference: $paymentIntent->id,
+            amount: $amount,
+            raw: $paymentIntent->toArray(),
+        );
+
+        $paymentIntent->status === PaymentIntent::STATUS_CANCELED
+            ? PaymentVoided::dispatch($type, $result, $context)
+            : PaymentVoidFailed::dispatch($type, $result, $context);
+
+        return $result;
+    }
+
+    public function refund(string $reference, Price $amount, array $context = []): PaymentResult
+    {
+        [$intentModel, $type, $context] = $this->resolveIntentModel($reference, $context);
+
+        try {
+            $refund = Stripe::getClient()->refunds->create([
+                'payment_intent' => $reference,
+                'amount' => StripeManager::toStripeAmount($amount->value, $amount->currency),
+            ]);
+        } catch (ApiErrorException $e) {
+            $result = $this->failure($amount, $e, $reference);
+            PaymentRefundFailed::dispatch($type, $result, $context);
+
+            return $result;
+        }
+
+        $result = new PaymentResult(
+            status: $refund->status !== 'failed' ? PaymentResultStatus::Succeeded : PaymentResultStatus::Failed,
+            reference: $refund->id,
+            amount: $amount,
+            raw: $refund->toArray(),
+        );
+
+        $refund->status !== 'failed'
+            ? PaymentRefunded::dispatch($type, $result, $context)
+            : PaymentRefundFailed::dispatch($type, $result, $context);
+
+        return $result;
+    }
+
+    private function rememberIntent(PaymentIntent $paymentIntent, string $type, array $context): ?StripePaymentIntent
+    {
+        if (! ($context['cart_id'] ?? null)) {
+            return null;
+        }
+
+        return StripePaymentIntent::create([
+            'intent_id' => $paymentIntent->id,
+            'cart_id' => $context['cart_id'],
+            'order_id' => $context['order_id'] ?? null,
+            'status' => $paymentIntent->status,
+            'payment_type' => $type,
+            'context' => json_encode($context),
+        ]);
+    }
+
+    /**
+     * The one lookup every method past initiate() shares: find the
+     * StripePaymentIntent row this $reference belongs to, then recover
+     * $type/$context from it — the original context, if any, always
+     * takes precedence over whatever the caller passed in (see
+     * handleCallback()'s own note: a webhook caller usually has none of
+     * its own).
+     *
+     * $typeFallback only matters when there's no $intentModel to read
+     * payment_type from — handleCallback() has its own $data['type'] to
+     * fall back to; capture()/void()/refund() have nothing better than ''.
+     *
+     * @return array{0: ?StripePaymentIntent, 1: string, 2: array<string, mixed>}
+     */
+    private function resolveIntentModel(string $reference, array $context, string $typeFallback = ''): array
+    {
+        $intentModel = StripePaymentIntent::where('intent_id', $reference)->first();
+
+        return [
+            $intentModel,
+            $intentModel?->payment_type ?? $typeFallback,
+            $this->decodeContext($intentModel) ?? $context,
+        ];
+    }
+
+    /**
+     * StripePaymentIntent is a vendor model (lunarphp/stripe) with no cast
+     * declared for our own 'context' column (added by boboko-core's own
+     * migration, see database/migrations/..._add_context_to_stripe_
+     * payment_intents.php) — we can't edit the vendor model to add one, so
+     * decode manually here instead of assuming Eloquent already did it.
+     *
+     * @return array<string, mixed>|null
+     */
+    private function decodeContext(?StripePaymentIntent $intentModel): ?array
+    {
+        if (! $intentModel || ! $intentModel->context) {
+            return null;
+        }
+
+        return json_decode($intentModel->context, associative: true) ?: null;
+    }
+
+    /**
+     * Converts a live Stripe PaymentIntent's own amount/currency back
+     * into Lunar's Price — the one place this class reads a Stripe
+     * response's amount without already holding the Price that produced
+     * it (handleCallback() has no $data['amount'] to fall back on, unlike
+     * pay()/authorize()).
+     */
+    private function priceFromIntent(PaymentIntent $paymentIntent): Price
+    {
+        $currency = Currency::whereRaw('lower(code) = ?', [strtolower($paymentIntent->currency)])->firstOrFail();
+
+        return new Price(
+            (int) StripeManager::fromStripeAmount($paymentIntent->amount, $currency),
+            $currency,
+        );
+    }
+
+    private function resultFromIntent(
+        string $type,
+        PaymentIntent $paymentIntent,
+        Price $amount,
+        array $context,
+        bool $authorizing,
+    ): PaymentResult {
+        $status = match ($paymentIntent->status) {
+            PaymentIntent::STATUS_SUCCEEDED => PaymentResultStatus::Succeeded,
+            PaymentIntent::STATUS_REQUIRES_CAPTURE => $authorizing ? PaymentResultStatus::Succeeded : PaymentResultStatus::Pending,
+            PaymentIntent::STATUS_CANCELED => PaymentResultStatus::Failed,
+            default => PaymentResultStatus::Pending,
+        };
+
+        $continuation = $status === PaymentResultStatus::Pending
+            ? new PaymentContinuation(PaymentContinuationType::ClientSecret, $paymentIntent->client_secret)
+            : null;
+
+        $result = new PaymentResult(
+            status: $status,
+            reference: $paymentIntent->id,
+            amount: $amount,
+            failureReason: $paymentIntent->last_payment_error->message ?? null,
+            raw: $paymentIntent->toArray(),
+            continuation: $continuation,
+        );
+
+        if ($status === PaymentResultStatus::Pending) {
+            return $result;
+        }
+
+        $succeeded = $status === PaymentResultStatus::Succeeded;
+
+        if ($authorizing) {
+            $succeeded
+                ? PaymentAuthorized::dispatch($type, $result, $context)
+                : PaymentAuthorizationFailed::dispatch($type, $result, $context);
+        } else {
+            $succeeded
+                ? PaymentCaptured::dispatch($type, $result, $context)
+                : PaymentCaptureFailed::dispatch($type, $result, $context);
+        }
+
+        return $result;
+    }
+
+    private function declined(string $type, Price $amount, ApiErrorException $e, array $context, bool $authorizing): PaymentResult
+    {
+        $result = $this->failure($amount, $e);
+
+        $authorizing
+            ? PaymentAuthorizationFailed::dispatch($type, $result, $context)
+            : PaymentCaptureFailed::dispatch($type, $result, $context);
+
+        return $result;
+    }
+
+    private function failure(Price $amount, ApiErrorException $e, string $reference = ''): PaymentResult
+    {
+        $stripeError = $e->getError();
+
+        return new PaymentResult(
+            status: PaymentResultStatus::Failed,
+            reference: $reference ?: ($stripeError->payment_intent->id ?? ''),
+            amount: $amount,
+            failureReason: $e->getMessage(),
+            retriable: in_array($stripeError->decline_code ?? null, [
+                'do_not_honor', 'insufficient_funds', 'card_velocity_exceeded',
+                'processing_error', 'try_again_later', 'issuer_not_available',
+            ], true),
+            raw: $stripeError?->toArray() ?? [],
+        );
     }
 }

src/Payment/Enums/PaymentContinuationType.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Modules\Core\Payment\Enums;
+
+/**
+ * What a caller of a Pending PaymentResult needs to do next, gateway-
+ * agnostically. Only meaningful when PaymentResult::$continuation is not
+ * null (status === Pending).
+ */
+enum PaymentContinuationType
+{
+    /** Send the shopper to $continuation->value (a URL) — a redirect-based gateway. */
+    case Redirect;
+
+    /** Hand $continuation->value (a client secret) to frontend JS — Stripe Elements-style. */
+    case ClientSecret;
+}

src/Payment/Enums/PaymentInitiationMode.php

@@ -1,32 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\Enums;
-
-/**
- * What a caller of InitiatesPayment::initiate() needs to do right now with
- * the PaymentInitiation it got back.
- */
-enum PaymentInitiationMode: string
-{
-    /**
-     * Send the shopper to redirectUrl (Viva, Klarna, EasyPay-style
-     * redirect flows) — they leave the site, pay, and return via a
-     * callback/webhook the driver handles separately.
-     */
-    case Redirect = 'redirect';
-
-    /**
-     * Hand clientSecret to frontend JS, which completes payment in-page
-     * (Stripe Elements, Nexi hosted fields) — no redirect away from the
-     * site.
-     */
-    case ClientSecret = 'client_secret';
-
-    /**
-     * Nothing further to do — the driver has already dispatched
-     * PaymentSucceeded (or will throw) by the time initiate() returns.
-     * Offline/no-gateway types (cash-on-delivery) are always this mode:
-     * there's no gateway round-trip to wait on.
-     */
-    case Immediate = 'immediate';
-}

src/Payment/Enums/PaymentResultStatus.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Modules\Core\Payment\Enums;
+
+/**
+ * The normalized outcome of a single gateway operation (pay, authorize,
+ * capture, void, refund) — never the gateway's own raw status string
+ * (Stripe's "succeeded", Nexi's "EXECUTED", Mastercard's own codes), so a
+ * caller never needs gateway-specific knowledge to know what happened.
+ */
+enum PaymentResultStatus
+{
+    case Succeeded;
+    case Failed;
+
+    /**
+     * The gateway hasn't resolved this operation yet and won't in the same
+     * call — e.g. Stripe's requires_action, a redirect the shopper hasn't
+     * completed. A driver returning this from initiate()/handleCallback()
+     * has not yet dispatched a terminal event; something else (a later
+     * callback) is expected to resolve it.
+     */
+    case Pending;
+}

src/Payment/Events/PaymentAuthorizationFailed.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * Dispatched when SupportsAuthorization::authorize() (or a
+ * HandlesPaymentCallback::handleCallback() resolving it later) determines
+ * the gateway did not grant the requested hold. $result->retriable is how
+ * a listener knows whether "try again with the same method" is reasonable
+ * — see PaymentResult's own docblock.
+ */
+class PaymentAuthorizationFailed
+{
+    use Dispatchable;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function __construct(
+        public readonly string $type,
+        public readonly PaymentResult $result,
+        public readonly array $context = [],
+    ) {}
+}

src/Payment/Events/PaymentAuthorized.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * Dispatched by a driver's SupportsAuthorization::authorize() (or, for an
+ * async gateway, HandlesPaymentCallback::handleCallback() resolving that
+ * same authorize() call later) once a hold has been placed — no funds have
+ * moved yet, see SupportsCaptures/SupportsVoids for what happens next.
+ *
+ * Carries $result (the full PaymentResult, not just a reference) plus
+ * $type and $context — same reasoning throughout Payment's events: Payment
+ * has no concept of a cart, an order, or a checkout fingerprint, so
+ * whatever a listener needs to react travels through $context untouched,
+ * opaque to Payment itself.
+ */
+class PaymentAuthorized
+{
+    use Dispatchable;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function __construct(
+        public readonly string $type,
+        public readonly PaymentResult $result,
+        public readonly array $context = [],
+    ) {}
+}

src/Payment/Events/PaymentCaptureFailed.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * Dispatched when SupportsPay::pay() or SupportsCaptures::capture() (or a
+ * HandlesPaymentCallback::handleCallback() resolving either later) fails
+ * to take the money — whether that's a sale-mode gateway declining the
+ * charge outright, or a capture call against an existing authorization
+ * being rejected. Same terminal-event symmetry as PaymentCaptured: this is
+ * the one "capture attempt failed" event regardless of which path
+ * produced it.
+ */
+class PaymentCaptureFailed
+{
+    use Dispatchable;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function __construct(
+        public readonly string $type,
+        public readonly PaymentResult $result,
+        public readonly array $context = [],
+    ) {}
+}

src/Payment/Events/PaymentCaptured.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * The one "money has actually been taken" event, dispatched from either of
+ * two different call paths that end at the same business fact:
+ *   - SupportsPay::pay() — an atomic authorize+capture gateway call
+ *     (Mastercard's "Pay", Stripe's capture_method=automatic, an offline
+ *     driver's immediate success).
+ *   - SupportsCaptures::capture() — settling a PRIOR authorize() hold.
+ * Whether the money moved in one gateway call or two is a driver-internal
+ * detail; a listener reacting to "a payment has been captured" never
+ * needs to know or care which path produced this event.
+ */
+class PaymentCaptured
+{
+    use Dispatchable;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function __construct(
+        public readonly string $type,
+        public readonly PaymentResult $result,
+        public readonly array $context = [],
+    ) {}
+}

src/Payment/Events/PaymentRefundFailed.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * Dispatched when SupportsRefunds::refund() fails to return settled funds
+ * — e.g. the gateway rejects refunding more than was originally captured.
+ */
+class PaymentRefundFailed
+{
+    use Dispatchable;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function __construct(
+        public readonly string $type,
+        public readonly PaymentResult $result,
+        public readonly array $context = [],
+    ) {}
+}

src/Payment/Events/PaymentRefunded.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * Dispatched by SupportsRefunds::refund() once settled funds (from a prior
+ * pay() or capture()) have actually been returned — full or partial.
+ * Independent of whether the original settlement was a sale or an
+ * authorize-then-capture: a refund only ever targets money that was
+ * genuinely taken, regardless of how it got taken.
+ */
+class PaymentRefunded
+{
+    use Dispatchable;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function __construct(
+        public readonly string $type,
+        public readonly PaymentResult $result,
+        public readonly array $context = [],
+    ) {}
+}

src/Payment/Events/PaymentSucceeded.php

@@ -1,39 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\Events;
-
-use Illuminate\Foundation\Events\Dispatchable;
-
-/**
- * Dispatched by a PaymentDriver once it has independently decided (by
- * whatever mechanism is native to its gateway) that a payment succeeded.
- * Deliberately carries nothing but what a payment fundamentally is —
- * $type, $reference, $amount — plus $context, an opaque bag the driver
- * received from whoever called confirm() and hands back unchanged here.
- *
- * Payment has no concept of a cart, an order, or a checkout fingerprint —
- * those are Checkout's concepts, and Checkout is only one possible
- * consumer of a successful payment (a future Subscriptions module renewing
- * on a recurring charge is another). $context is how a caller like
- * CheckoutService::confirmPayment() smuggles what it needs to react
- * (cart_id, fingerprint) through Payment without Payment ever reading or
- * caring what's inside — each listener interprets $context on its own
- * terms, or ignores the event entirely if the keys it needs aren't there.
- */
-class PaymentSucceeded
-{
-    use Dispatchable;
-
-    /**
-     * $amount is in the currency's minor unit, same convention as
-     * Lunar\Base\Casts\Price.
-     *
-     * @param  array<string, mixed>  $context
-     */
-    public function __construct(
-        public readonly string $type,
-        public readonly string $reference,
-        public readonly int $amount,
-        public readonly array $context = [],
-    ) {}
-}

src/Payment/Events/PaymentVoidFailed.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * Dispatched when SupportsVoids::void() fails to release a prior
+ * authorization — e.g. the hold already expired or was already captured,
+ * so there was nothing left to void.
+ */
+class PaymentVoidFailed
+{
+    use Dispatchable;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function __construct(
+        public readonly string $type,
+        public readonly PaymentResult $result,
+        public readonly array $context = [],
+    ) {}
+}

src/Payment/Events/PaymentVoided.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Modules\Core\Payment\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Modules\Core\Payment\DTOs\PaymentResult;
+
+/**
+ * Dispatched by SupportsVoids::void() once a prior authorization hold has
+ * been released without ever settling — the "actually, never mind" exit
+ * from an authorize() that SupportsCaptures::capture() would otherwise
+ * have settled. No funds ever moved, so this is distinct from
+ * PaymentRefunded (which reverses money that was actually taken).
+ */
+class PaymentVoided
+{
+    use Dispatchable;
+
+    /**
+     * @param  array<string, mixed>  $context
+     */
+    public function __construct(
+        public readonly string $type,
+        public readonly PaymentResult $result,
+        public readonly array $context = [],
+    ) {}
+}

src/Payment/Exceptions/PaymentNotConfirmedException.php

@@ -1,22 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\Exceptions;
-
-use RuntimeException;
-use Throwable;
-
-/**
- * Thrown by a Modules\Core\Payment\Contracts\PaymentDriver when the
- * gateway has not confirmed payment — wrong/expired intent, already
- * processed, or the gateway itself rejects the confirmation. A driver
- * throws this instead of silently placing the order: CheckoutService::
- * placeOrder() must only ever be called once a driver has positively
- * confirmed payment, never as a fallback.
- */
-class PaymentNotConfirmedException extends RuntimeException
-{
-    public function __construct(string $message, ?Throwable $previous = null)
-    {
-        parent::__construct($message, previous: $previous);
-    }
-}

src/Payment/Http/Controllers/StripeWebhookController.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Modules\Core\Payment\Http\Controllers;
+
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Modules\Core\Payment\Drivers\StripePaymentDriver;
+use Stripe\Webhook;
+
+/**
+ * A boboko-owned webhook endpoint for Stripe — deliberately NOT
+ * lunarphp/stripe's own route (vendor/lunarphp/stripe/routes/webhooks.php),
+ * which dispatches into Lunar's own Payments::driver('stripe') flow (the
+ * flow StripePaymentDriver was built to replace, see that class's own
+ * docblock). Signature verification is handled by
+ * Lunar\Stripe\Http\Middleware\StripeWebhookMiddleware, registered on this
+ * route (see src/Payment/routes/webhooks.php) — pure Stripe SDK
+ * verification + event-type filtering, safe to reuse even though this
+ * controller never touches the rest of that vendor package's flow. This
+ * controller verifies the signature again itself (Webhook::constructEvent())
+ * to get the constructed Event object — the middleware doesn't stash one
+ * anywhere reusable, it only gates the request through.
+ *
+ * Resolves the driver directly by class, not via
+ * Modules\Core\Payment\Services\PaymentDriverResolver — this endpoint is
+ * inherently Stripe-specific (Stripe's own webhook payload carries no
+ * boboko payment-type key, only its own payment_intent id), and
+ * StripePaymentDriver::handleCallback() already recovers $type itself
+ * from the StripePaymentIntent row pay()/authorize() wrote.
+ */
+class StripeWebhookController extends Controller
+{
+    public function __invoke(Request $request, StripePaymentDriver $driver): JsonResponse
+    {
+        $event = Webhook::constructEvent(
+            $request->getContent(),
+            $request->header('Stripe-Signature'),
+            config('services.stripe.webhooks.lunar'),
+        );
+
+        $driver->handleCallback($event->data->object->id, $event->data->object->toArray());
+
+        return response()->json(['webhook_successful' => true]);
+    }
+}

src/Payment/Listeners/ApplyOfflinePaymentStatus.php

@@ -1,36 +0,0 @@
-<?php
-
-namespace Modules\Core\Payment\Listeners;
-
-use Modules\Core\Checkout\Events\OrderPlaced;
-use Modules\Core\Payment\Drivers\OfflinePaymentDriver;
-
-/**
- * The status-mapping step OfflinePaymentDriver used to do inline right
- * after CheckoutService::placeOrder() returned — moved out to a listener
- * since confirm() can no longer rely on that return value (see
- * PaymentDriver's docblock).
- *
- * Every offline-style type shares OfflinePaymentDriver, so
- * $order->meta['payment_method'] is checked against
- * config('lunar.payments.types') to confirm the placed order actually
- * belongs to one of them, rather than assuming every OrderPlaced is
- * this listener's to act on — a Stripe order placed via
- * StripePaymentDriver fires the same event.
- */
-class ApplyOfflinePaymentStatus
-{
-    public function handle(OrderPlaced $event): void
-    {
-        $order = $event->order;
-        $type = $order->meta['payment_method'] ?? null;
-
-        if (! $type || config("lunar.payments.types.{$type}.payment_driver") !== OfflinePaymentDriver::class) {
-            return;
-        }
-
-        $order->update([
-            'status' => config("lunar.payments.types.{$type}.authorized", $order->status),
-        ]);
-    }
-}

src/Payment/Services/PaymentDriverResolver.php

@@ -2,14 +2,19 @@
 
 namespace Modules\Core\Payment\Services;
 
-use Modules\Core\Payment\Contracts\PaymentDriver;
-
 /**
  * Resolves a payment type key (e.g. 'stripe', 'cash-on-delivery') to its
- * registered PaymentDriver — extracted out of CheckoutService so both it
- * and anything else needing the same lookup (e.g. a listener reacting to
- * OrderPlaced, which has no reason to depend on Checkout's own service)
- * share one implementation instead of duplicating this config read.
+ * registered driver instance — extracted out of CheckoutService so both it
+ * and anything else needing the same lookup share one implementation
+ * instead of duplicating this config read.
+ *
+ * Returns a plain object, not a shared interface — Payment's own drivers
+ * implement several independent, orthogonal capability interfaces at once
+ * (Configurable, SupportsPay, SupportsAuthorization, ...; see
+ * StripePaymentDriver implementing all six). There is no single common
+ * "PaymentDriver" contract to type this against; a caller checks
+ * `instanceof SupportsPay` / `instanceof SupportsAuthorization` itself,
+ * the same way Payment's own contracts are designed to be consumed.
  */
 class PaymentDriverResolver
 {
@@ -20,7 +25,7 @@ class PaymentDriverResolver
      * can filter unresolvable types silently rather than treating "not
      * registered" as an error condition when just checking availability.
      */
-    public function resolve(string $type): ?PaymentDriver
+    public function resolve(string $type): ?object
     {
         $driverClass = config("lunar.payments.types.{$type}.payment_driver");
 

src/Payment/routes/webhooks.php

@@ -0,0 +1,14 @@
+<?php
+
+use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken;
+use Illuminate\Support\Facades\Route;
+use Lunar\Stripe\Http\Middleware\StripeWebhookMiddleware;
+use Modules\Core\Payment\Http\Controllers\StripeWebhookController;
+
+Route::post(
+    config('payment.stripe.webhook_path', 'payments/stripe/webhook'),
+    StripeWebhookController::class
+)
+    ->middleware([StripeWebhookMiddleware::class, 'api'])
+    ->withoutMiddleware([VerifyCsrfToken::class])
+    ->name('payment.stripe.webhook');

src/Providers/OrderServiceProvider.php

@@ -7,6 +7,7 @@ use Illuminate\Support\ServiceProvider;
 use Lunar\Models\Order;
 use Lunar\Models\Transaction;
 use Modules\Core\Notification\NotificationRegistry;
+use Modules\Core\Order\Listeners\ApplyResolvedPaymentStatus;
 use Modules\Core\Order\Listeners\DeriveOrderDeliveredFromShipment;
 use Modules\Core\Order\Notifications\OrderCapturedNotification;
 use Modules\Core\Order\Notifications\OrderDeliveredNotification;
@@ -15,6 +16,8 @@ use Modules\Core\Order\Notifications\OrderStatusUpdatedNotification;
 use Modules\Core\Order\Observers\OrderObserver;
 use Modules\Core\Order\Observers\TransactionObserver;
 use Modules\Core\Order\Support\OrderStatus;
+use Modules\Core\Payment\Events\PaymentAuthorized;
+use Modules\Core\Payment\Events\PaymentCaptured;
 use Modules\Core\Shipping\Events\ShipmentStatusUpdatedByCarrier;
 
 class OrderServiceProvider extends ServiceProvider
@@ -28,6 +31,8 @@ class OrderServiceProvider extends ServiceProvider
         Order::macro('fulfillmentStatus', fn () => OrderStatus::fulfillment($this));
 
         Event::listen(ShipmentStatusUpdatedByCarrier::class, DeriveOrderDeliveredFromShipment::class);
+        Event::listen(PaymentCaptured::class, ApplyResolvedPaymentStatus::class);
+        Event::listen(PaymentAuthorized::class, ApplyResolvedPaymentStatus::class);
 
         NotificationRegistry::get()->register([
             OrderDeliveredNotification::class,

src/Providers/PaymentServiceProvider.php

@@ -38,5 +38,7 @@ class PaymentServiceProvider extends ServiceProvider
         }
 
         config(['lunar.cart.pipelines.cart' => $cartPipeline]);
+
+        $this->loadRoutesFrom(__DIR__ . '/../Payment/routes/webhooks.php');
     }
 }

src/Shipping/Carriers/Acs/AcsRateDriver.php

@@ -4,7 +4,7 @@ namespace Modules\Core\Shipping\Carriers\Acs;
 
 use Lunar\DataTypes\Price;
 use Lunar\DataTypes\ShippingOption;
-use Lunar\Shipping\DTOs\ShippingOptionRequest;
+use Lunar\Shipping\DataTransferObjects\ShippingOptionRequest;
 use Lunar\Shipping\Interfaces\ShippingRateInterface;
 use Lunar\Shipping\Models\ShippingRate;
 use Modules\Core\Shipping\Carriers\Acs\Exceptions\AcsApiException;

src/Shipping/Carriers/BoxNow/BoxNowRateDriver.php

@@ -3,7 +3,7 @@
 namespace Modules\Core\Shipping\Carriers\BoxNow;
 
 use Lunar\DataTypes\ShippingOption;
-use Lunar\Shipping\DTOs\ShippingOptionRequest;
+use Lunar\Shipping\DataTransferObjects\ShippingOptionRequest;
 use Lunar\Shipping\Interfaces\ShippingRateInterface;
 use Lunar\Shipping\Models\ShippingRate;
 use Modules\Core\Shipping\Concerns\ResolvesFixedPricing;