pay 6.8.0 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de3a99204ee0e081f59774da0369b8e820a8d1fb33d810871dbc62ec009012c1
-  data.tar.gz: 19bbcd3c80230b270b2fc60338d410d6ceb37e2dc9466d1674f8552ecbdf46e9
+  metadata.gz: bcb0963ca95179e0b56cf07bfdd56e0341d2ca2ae52fc6cb65014251bc62f3a3
+  data.tar.gz: 9970fc734d34bacb0c35dfe327c59e80e906ed5a8d702c5feed4c68fbd5b321a
 SHA512:
-  metadata.gz: 0f504f26b84e856d1fd241e61537f1203539b76f58f9af69a768316e97e710ff24b5a79ac2179a1c335d5691283dc9e097476e696b1551ec212046f8dd97f026
-  data.tar.gz: 87e4ae3cc89868ed3faa76e3a73b0aaba568c87d33e7c1c003619c4fc69887edcce7fab67f3c40cb57924423a4f9c0b2328cebf1491164ae975c79f586fa7cb9
+  metadata.gz: fec7e0d0f3ad62cbcc21b533680041176280035e0ed2a0f88ef5e871535cff60f5b8965b0ce0687220c66610e3a121aa52e1dcc00f97c416512a3f0a446854a1
+  data.tar.gz: cc039d575168e1cb8f31f331ce6baddf063b69f150dab928d51293c10a0c3a61eb962598885b8be72eb3122cf557360a76f88bc1f351f965c9ce0bf8727e75ed

data/app/controllers/pay/webhooks/paddle_billing_controller.rb

@@ -0,0 +1,51 @@
+module Pay
+  module Webhooks
+    class PaddleBillingController < Pay::ApplicationController
+      if Rails.application.config.action_controller.default_protect_from_forgery
+        skip_before_action :verify_authenticity_token
+      end
+
+      def create
+        if valid_signature?(request.headers["Paddle-Signature"])
+          queue_event(verify_params.as_json)
+          head :ok
+        else
+          head :bad_request
+        end
+      rescue Pay::PaddleBilling::Error
+        head :bad_request
+      end
+
+      private
+
+      def queue_event(event)
+        return unless Pay::Webhooks.delegator.listening?("paddle_billing.#{params[:event_type]}")
+
+        record = Pay::Webhook.create!(processor: :paddle_billing, event_type: params[:event_type], event: event)
+        Pay::Webhooks::ProcessJob.perform_later(record)
+      end
+
+      # Pass Paddle signature from request.headers["Paddle-Signature"]
+      def valid_signature?(paddle_signature)
+        return false if paddle_signature.blank?
+
+        ts_part, h1_part = paddle_signature.split(";")
+        _, ts = ts_part.split("=")
+        _, h1 = h1_part.split("=")
+
+        signed_payload = "#{ts}:#{request.raw_post}"
+
+        key = Pay::PaddleBilling.signing_secret
+        data = signed_payload
+        digest = OpenSSL::Digest.new("sha256")
+
+        hmac = OpenSSL::HMAC.hexdigest(digest, key, data)
+        hmac == h1
+      end
+
+      def verify_params
+        params.except(:action, :controller).permit!
+      end
+    end
+  end
+end

data/app/controllers/pay/webhooks/{paddle_controller.rb → paddle_classic_controller.rb}

@@ -1,6 +1,6 @@
 module Pay
   module Webhooks
-    class PaddleController < Pay::ApplicationController
+    class PaddleClassicController < Pay::ApplicationController
       if Rails.application.config.action_controller.default_protect_from_forgery
         skip_before_action :verify_authenticity_token
       end
@@ -8,24 +8,24 @@ module Pay
       def create
         queue_event(verified_event)
         head :ok
-      rescue Pay::Paddle::Error
+      rescue Pay::PaddleClassic::Error
         head :bad_request
       end
 
       private
 
       def queue_event(event)
-        return unless Pay::Webhooks.delegator.listening?("paddle.#{params[:alert_name]}")
+        return unless Pay::Webhooks.delegator.listening?("paddle_classic.#{params[:alert_name]}")
 
-        record = Pay::Webhook.create!(processor: :paddle, event_type: params[:alert_name], event: event)
+        record = Pay::Webhook.create!(processor: :paddle_classic, event_type: params[:alert_name], event: event)
         Pay::Webhooks::ProcessJob.perform_later(record)
       end
 
       def verified_event
         event = verify_params.as_json
-        verifier = Pay::Paddle::Webhooks::SignatureVerifier.new(event)
+        verifier = Pay::PaddleClassic::Webhooks::SignatureVerifier.new(event)
         return event if verifier.verify
-        raise Pay::Paddle::Error, "Unable to verify Paddle webhook event"
+        raise Pay::PaddleClassic::Error, "Unable to verify Paddle webhook event"
       end
 
       def verify_params

data/app/mailers/pay/application_mailer.rb

@@ -1,6 +1,10 @@
 module Pay
   class ApplicationMailer < ActionMailer::Base
-    default from: Pay.support_email || ApplicationMailer.default_params[:from]
+    def self.default_from_address
+      Pay.support_email || ::ApplicationMailer.default_params[:from]
+    end
+
+    default from: default_from_address
     layout "mailer"
   end
 end

data/app/models/pay/charge.rb

@@ -18,7 +18,6 @@ module Pay
     # Store the payment method kind (card, paypal, etc)
     store_accessor :data, :paddle_receipt_url
     store_accessor :data, :stripe_receipt_url
-    store_accessor :data, :stripe_account
 
     # Payment method attributes
     store_accessor :data, :payment_method_type # card, paypal, sepa, etc
@@ -45,7 +44,7 @@ module Pay
     store_accessor :data, :refunds # array of refunds
 
     # Helpers for payment processors
-    %w[braintree stripe paddle fake_processor].each do |processor_name|
+    %w[braintree stripe paddle_billing paddle_classic fake_processor].each do |processor_name|
       define_method "#{processor_name}?" do
         customer.processor == processor_name
       end

data/app/models/pay/customer.rb

@@ -16,7 +16,6 @@ module Pay
     attribute :payment_method_token, :string
 
     # Account(s) for marketplace payments
-    store_accessor :data, :stripe_account
     store_accessor :data, :braintree_account
 
     # Stripe invoice credit balance is a Hash-like object { "usd" => 1234 }
@@ -26,7 +25,7 @@ module Pay
     delegate :email, to: :owner
     delegate_missing_to :pay_processor
 
-    %w[stripe braintree paddle fake_processor].each do |processor_name|
+    %w[stripe braintree paddle_billing paddle_classic fake_processor].each do |processor_name|
       scope processor_name, -> { where(processor: processor_name) }
 
       define_method "#{processor_name}?" do

data/app/models/pay/merchant.rb

@@ -18,9 +18,7 @@ module Pay
     end
 
     def onboarding_complete?
-      ActiveModel::Type::Boolean.new.cast(
-        (data.presence || {})["onboarding_complete"]
-      )
+      ActiveModel::Type::Boolean.new.cast(data&.fetch("onboarding_complete")) || false
     end
   end
 end

data/app/models/pay/payment_method.rb

@@ -4,12 +4,11 @@ module Pay
 
     belongs_to :customer
 
-    store_accessor :data, :stripe_account
     store_accessor :data, :brand # Visa, Mastercard, Discover, PayPal
     store_accessor :data, :last4
     store_accessor :data, :exp_month
     store_accessor :data, :exp_year
-    store_accessor :data, :email # PayPal email, etc
+    store_accessor :data, :email # PayPal, Stripe Link, etc
     store_accessor :data, :username
     store_accessor :data, :bank
 

data/app/models/pay/subscription.rb

@@ -4,14 +4,16 @@ module Pay
 
     # Associations
     belongs_to :customer
+    belongs_to :payment_method, optional: true, primary_key: :processor_id
     has_many :charges
 
     # Scopes
     scope :for_name, ->(name) { where(name: name) }
-    scope :on_trial, -> { where.not(trial_ends_at: nil).where("#{table_name}.trial_ends_at > ?", Time.current) }
-    scope :cancelled, -> { where.not(ends_at: nil) }
-    scope :on_grace_period, -> { cancelled.where("#{table_name}.ends_at > ?", Time.current) }
-    scope :active, -> { where(status: ["trialing", "active", "canceled"], ends_at: nil).pause_not_started.or(on_grace_period).or(on_trial) }
+    scope :on_trial, -> { where("trial_ends_at > ?", Time.current) }
+    scope :canceled, -> { where.not(ends_at: nil) }
+    scope :cancelled, -> { canceled }
+    scope :on_grace_period, -> { where("#{table_name}.ends_at IS NOT NULL AND #{table_name}.ends_at > ?", Time.current) }
+    scope :active, -> { where(status: ["trialing", "active"]).pause_not_started.where("#{table_name}.ends_at IS NULL OR #{table_name}.ends_at > ?", Time.current).where("trial_ends_at IS NULL OR trial_ends_at > ?", Time.current) }
     scope :paused, -> { where(status: "paused").or(where("pause_starts_at <= ?", Time.current)) }
     scope :pause_not_started, -> { where("pause_starts_at IS NULL OR pause_starts_at > ?", Time.current) }
     scope :active_or_paused, -> { active.or(paused) }
@@ -27,7 +29,6 @@ module Pay
 
     store_accessor :data, :paddle_update_url
     store_accessor :data, :paddle_cancel_url
-    store_accessor :data, :stripe_account
     store_accessor :data, :subscription_items
 
     attribute :prorate, :boolean, default: true
@@ -42,7 +43,7 @@ module Pay
     delegate_missing_to :payment_processor
 
     # Helper methods for payment processors
-    %w[braintree stripe paddle fake_processor].each do |processor_name|
+    %w[braintree stripe paddle_billing paddle_classic fake_processor].each do |processor_name|
       define_method "#{processor_name}?" do
         customer.processor == processor_name
       end
@@ -106,9 +107,9 @@ module Pay
 
     # If you cancel during a trial, you should still retain access until the end of the trial
     # Otherwise a subscription is active unless it has ended or is currently paused
-    # Check the subscription status so we don't accidentally consider "incomplete", "past_due", or other statuses as active
+    # Check the subscription status so we don't accidentally consider "incomplete", "unpaid", or other statuses as active
     def active?
-      ["trialing", "active", "canceled"].include?(status) &&
+      ["trialing", "active"].include?(status) &&
         (!(canceled? || paused?) || on_trial? || on_grace_period?)
     end
 
@@ -160,9 +161,7 @@ module Pay
     private
 
     def cancel_if_active
-      if active?
-        cancel_now!
-      end
+      cancel_now! if active?
     rescue => e
       Rails.logger.info "[Pay] Unable to automatically cancel subscription `#{customer.processor} #{id}`: #{e.message}"
     end

data/app/models/pay/webhook.rb

@@ -17,7 +17,9 @@ module Pay
       case processor
       when "braintree"
         Pay.braintree_gateway.webhook_notification.parse(event["bt_signature"], event["bt_payload"])
-      when "paddle"
+      when "paddle_billing"
+        to_recursive_ostruct(event["data"])
+      when "paddle_classic"
         to_recursive_ostruct(event)
       when "stripe"
         ::Stripe::Event.construct_from(event)
@@ -26,11 +28,14 @@ module Pay
       end
     end
 
-    def to_recursive_ostruct(hash)
-      result = hash.each_with_object({}) do |(key, val), memo|
-        memo[key] = val.is_a?(Hash) ? to_recursive_ostruct(val) : val
+    def to_recursive_ostruct(obj)
+      if obj.is_a?(Hash)
+        OpenStruct.new(obj.map { |key, val| [key, to_recursive_ostruct(val)] }.to_h)
+      elsif obj.is_a?(Array)
+        obj.map { |o| to_recursive_ostruct(o) }
+      else # Assumed to be a primitive value
+        obj
       end
-      OpenStruct.new(result)
     end
   end
 end

data/app/views/pay/payments/show.html.erb

@@ -64,7 +64,7 @@
 </div>
 
 <script type="module">
-  window.stripe = Stripe('<%= Pay::Stripe.public_key %>');
+  window.stripe = Stripe('<%= Pay::Stripe.public_key %>')
 
   import { Application, Controller } from 'https://unpkg.com/@hotwired/stimulus/dist/stimulus.js'
   const application = Application.start()
@@ -83,34 +83,27 @@
 
     connect() {
       if (this.hasCardTarget) {
-        this.elements = stripe.elements()
-        this.cardElement = this.elements.create("card")
-        this.cardElement.mount(this.cardTarget)
+        this.elements = stripe.elements({clientSecret: this.clientSecretValue})
+        this.payment =  this.elements.create('payment')
+        this.payment.mount(this.cardTarget)
       }
     }
 
     statusValueChanged() {
       switch(this.statusValue) {
         case "requires_action":
-          stripe.confirmCardPayment(this.clientSecretValue).then(this.handleConfirmResult.bind(this))
-          break;
+          this.processingValue = true
+          stripe.confirmPayment({clientSecret: this.clientSecretValue, confirmParams: { return_url: document.location.href }}).then(this.handleConfirmResult.bind(this))
+          break
         case "requires_payment_method":
           this.cardFieldsTarget.classList.toggle("hidden", false)
-          break;
+          break
       }
     }
 
     confirmPayment() {
       this.processingValue = true
-      this.completeValue = false
-      stripe.confirmCardPayment(this.clientSecretValue, {
-        payment_method: {
-          card: this.cardElement,
-          billing_details: { name: this.nameTarget.value }
-        },
-        save_payment_method: this.customerValue != "",
-        setup_future_usage: 'off_session',
-      }).then(this.handleConfirmResult.bind(this))
+      stripe.confirmPayment({elements: this.elements, confirmParams: { return_url: document.location.href }}).then(this.handleConfirmResult.bind(this))
     }
 
     handleConfirmResult(result) {
@@ -125,7 +118,7 @@
           this.statusValue = result.error.payment_intent.status
         }
       } else {
-        this.completeValue = true;
+        this.completeValue = true
         this.successMessageValue = '<%=t "pay.requires_action.success" %>'
       }
     }

data/config/locales/en.yml

@@ -2,7 +2,7 @@ en:
   pay:
     successful:
       header: "Payment Successful"
-      description: "This payment was already successfully confirmed."
+      description: "This payment was successfully confirmed."
     cancelled:
       header: "Payment Cancelled"
       description: "This payment was cancelled."

data/config/routes.rb

@@ -4,5 +4,6 @@ Pay::Engine.routes.draw do
   resources :payments, only: [:show], module: :pay
   post "webhooks/stripe", to: "pay/webhooks/stripe#create" if Pay::Stripe.enabled?
   post "webhooks/braintree", to: "pay/webhooks/braintree#create" if Pay::Braintree.enabled?
-  post "webhooks/paddle", to: "pay/webhooks/paddle#create" if Pay::Paddle.enabled?
+  post "webhooks/paddle_billing", to: "pay/webhooks/paddle_billing#create" if Pay::PaddleBilling.enabled?
+  post "webhooks/paddle_classic", to: "pay/webhooks/paddle_classic#create" if Pay::PaddleClassic.enabled?
 end

data/db/migrate/1_create_pay_tables.rb

@@ -8,10 +8,11 @@ class CreatePayTables < ActiveRecord::Migration[6.0]
       t.string :processor_id
       t.boolean :default
       t.public_send Pay::Adapter.json_column_type, :data
+      t.string :stripe_account
       t.datetime :deleted_at
       t.timestamps
     end
-    add_index :pay_customers, [:owner_type, :owner_id, :deleted_at, :default], name: :pay_customer_owner_index
+    add_index :pay_customers, [:owner_type, :owner_id, :deleted_at], name: :pay_customer_owner_index, unique: true
     add_index :pay_customers, [:processor, :processor_id], unique: true
 
     create_table :pay_merchants, id: primary_key_type do |t|
@@ -30,6 +31,7 @@ class CreatePayTables < ActiveRecord::Migration[6.0]
       t.boolean :default
       t.string :type
       t.public_send Pay::Adapter.json_column_type, :data
+      t.string :stripe_account
       t.timestamps
     end
     add_index :pay_payment_methods, [:customer_id, :processor_id], unique: true
@@ -52,6 +54,8 @@ class CreatePayTables < ActiveRecord::Migration[6.0]
       t.decimal :application_fee_percent, precision: 8, scale: 2
       t.public_send Pay::Adapter.json_column_type, :metadata
       t.public_send Pay::Adapter.json_column_type, :data
+      t.string :stripe_account
+      t.string :payment_method_id
       t.timestamps
     end
     add_index :pay_subscriptions, [:customer_id, :processor_id], unique: true
@@ -68,6 +72,7 @@ class CreatePayTables < ActiveRecord::Migration[6.0]
       t.integer :amount_refunded
       t.public_send Pay::Adapter.json_column_type, :metadata
       t.public_send Pay::Adapter.json_column_type, :data
+      t.string :stripe_account
       t.timestamps
     end
     add_index :pay_charges, [:customer_id, :processor_id], unique: true

data/lib/pay/braintree/subscription.rb

@@ -35,8 +35,9 @@ module Pay
           created_at: object.created_at,
           current_period_end: object.billing_period_end_date,
           current_period_start: object.billing_period_start_date,
+          payment_method_id: object.payment_method_token,
           processor_plan: object.plan_id,
-          status: object.status.underscore,
+          status: object.status.parameterize(separator: "_"),
           trial_ends_at: (object.created_at + object.trial_duration.send(object.trial_duration_unit) if object.trial_period)
         }
 
@@ -77,6 +78,9 @@ module Pay
       end
 
       def cancel(**options)
+        return if canceled?
+
+        # Braintree doesn't allow canceling at period end while on trial, so trials are canceled immediately
         result = if on_trial?
           gateway.subscription.cancel(processor_id)
         else
@@ -90,6 +94,8 @@ module Pay
       end
 
       def cancel_now!(**options)
+        return if canceled?
+
         result = gateway.subscription.cancel(processor_id)
         pay_subscription.sync!(object: result.subscription)
       rescue ::Braintree::BraintreeError => e
@@ -112,8 +118,12 @@ module Pay
         raise NotImplementedError, "Braintree does not support pausing subscriptions"
       end
 
+      def resumable?
+        on_grace_period?
+      end
+
       def resume
-        unless on_grace_period?
+        unless resumable?
           raise StandardError, "You can only resume subscriptions within their grace period."
         end
 

data/lib/pay/engine.rb

@@ -26,13 +26,14 @@ module Pay
     config.before_initialize do
       Pay::Stripe.configure_webhooks if Pay::Stripe.enabled?
       Pay::Braintree.configure_webhooks if Pay::Braintree.enabled?
-      Pay::Paddle.configure_webhooks if Pay::Paddle.enabled?
+      Pay::PaddleBilling.configure_webhooks if Pay::PaddleBilling.enabled?
+      Pay::PaddleClassic.configure_webhooks if Pay::PaddleClassic.enabled?
     end
 
     config.to_prepare do
       Pay::Stripe.setup if Pay::Stripe.enabled?
       Pay::Braintree.setup if Pay::Braintree.enabled?
-      Pay::Paddle.setup if Pay::Paddle.enabled?
+      Pay::PaddleBilling.setup if Pay::PaddleBilling.enabled?
 
       if defined?(::Receipts::VERSION)
         if Pay::Engine.version_matches?(required: "~> 2", current: ::Receipts::VERSION)

data/lib/pay/env.rb

@@ -21,9 +21,7 @@ module Pay
     def find_value_by_name(scope, name)
       ENV["#{scope.upcase}_#{name.upcase}"] ||
         credentials&.dig(env, scope, name) ||
-        credentials&.dig(scope, name) ||
-        secrets&.dig(env, scope, name) ||
-        secrets&.dig(scope, name)
+        credentials&.dig(scope, name)
     rescue ActiveSupport::MessageEncryptor::InvalidMessage
       Rails.logger.error <<~MESSAGE
         Rails was unable to decrypt credentials. Pay checks the Rails credentials to look for API keys for payment processors.
@@ -38,10 +36,6 @@ module Pay
       Rails.env.to_sym
     end
 
-    def secrets
-      Rails.application.secrets if Rails.application.respond_to?(:secrets)
-    end
-
     def credentials
       Rails.application.credentials if Rails.application.respond_to?(:credentials)
     end

data/lib/pay/fake_processor/subscription.rb

@@ -29,6 +29,8 @@ module Pay
       # With trial, sets end to trial end (mimicing Stripe)
       # Without trial, sets can ends_at to end of month
       def cancel(**options)
+        return if canceled?
+
         if pay_subscription.on_trial?
           pay_subscription.update(ends_at: pay_subscription.trial_ends_at)
         else
@@ -37,6 +39,8 @@ module Pay
       end
 
       def cancel_now!(**options)
+        return if canceled?
+
         ends_at = Time.current
         pay_subscription.update(
           status: :canceled,
@@ -61,10 +65,16 @@ module Pay
         pay_subscription.update(status: :paused, trial_ends_at: Time.current)
       end
 
+      def resumable?
+        on_grace_period? || paused?
+      end
+
       def resume
-        unless on_grace_period? || paused?
+        unless resumable?
           raise StandardError, "You can only resume subscriptions within their grace period."
         end
+
+        pay_subscription.update(status: :active, trial_ends_at: nil, ends_at: nil)
       end
 
       def swap(plan, **options)

data/lib/pay/lemon_squeezy/billable.rb

@@ -0,0 +1,90 @@
+module Pay
+  module PaddleBilling
+    class Billable
+      attr_reader :pay_customer
+
+      delegate :processor_id,
+        :processor_id?,
+        :email,
+        :customer_name,
+        :card_token,
+        to: :pay_customer
+
+      def initialize(pay_customer)
+        @pay_customer = pay_customer
+      end
+
+      def customer_attributes
+        {email: email, name: customer_name}
+      end
+
+      # Retrieves a Paddle::Customer object
+      #
+      # Finds an existing Paddle::Customer if processor_id exists
+      # Creates a new Paddle::Customer using `email` and `customer_name` if empty processor_id
+      #
+      # Returns a Paddle::Customer object
+      def customer
+        if processor_id?
+          ::Paddle::Customer.retrieve(id: processor_id)
+        else
+          sc = ::Paddle::Customer.create(email: email, name: customer_name)
+          pay_customer.update!(processor_id: sc.id)
+          sc
+        end
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleBilling::Error, e
+      end
+
+      # Syncs name and email to Paddle::Customer
+      # You can also pass in other attributes that will be merged into the default attributes
+      def update_customer!(**attributes)
+        customer unless processor_id?
+        attrs = customer_attributes.merge(attributes)
+        ::Paddle::Customer.update(id: processor_id, **attrs)
+      end
+
+      def charge(amount, options = {})
+        return Pay::Error unless options
+
+        items = options[:items]
+        opts = options.except(:items).merge(customer_id: processor_id)
+        transaction = ::Paddle::Transaction.create(items: items, **opts)
+
+        attrs = {
+          amount: transaction.details.totals.grand_total,
+          created_at: transaction.created_at,
+          currency: transaction.currency_code,
+          metadata: transaction.details.line_items&.first&.id
+        }
+
+        charge = pay_customer.charges.find_or_initialize_by(processor_id: transaction.id)
+        charge.update(attrs)
+        charge
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleBilling::Error, e
+      end
+
+      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
+        # pass
+      end
+
+      # Paddle does not use payment method tokens. The method signature has it here
+      # to have a uniform API with the other payment processors.
+      def add_payment_method(token = nil, default: true)
+        Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer)
+      end
+
+      def trial_end_date(subscription)
+        return unless subscription.state == "trialing"
+        Time.zone.parse(subscription.next_payment[:date]).end_of_day
+      end
+
+      def processor_subscription(subscription_id, options = {})
+        ::Paddle::Subscription.retrieve(id: subscription_id, **options)
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleBilling::Error, e
+      end
+    end
+  end
+end

data/lib/pay/lemon_squeezy/charge.rb

@@ -0,0 +1,68 @@
+module Pay
+  module PaddleBilling
+    class Charge
+      attr_reader :pay_charge
+
+      delegate :processor_id, :customer, to: :pay_charge
+
+      def initialize(pay_charge)
+        @pay_charge = pay_charge
+      end
+
+      def self.sync(charge_id, object: nil, try: 0, retries: 1)
+        # Skip loading the latest charge details from the API if we already have it
+        object ||= ::Paddle::Transaction.retrieve(id: charge_id)
+
+        # Ignore transactions that aren't completed
+        return unless object.status == "completed"
+
+        # Ignore charges without a Customer
+        return if object.customer_id.blank?
+
+        pay_customer = Pay::Customer.find_by(processor: :paddle_billing, processor_id: object.customer_id)
+        return unless pay_customer
+
+        # Ignore transactions that are payment method changes
+        # But update the customer's payment method
+        if object.origin == "subscription_payment_method_change"
+          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
+          return
+        end
+
+        attrs = {
+          amount: object.details.totals.grand_total,
+          created_at: object.created_at,
+          currency: object.currency_code,
+          metadata: object.details.line_items&.first&.id,
+          subscription: pay_customer.subscriptions.find_by(processor_id: object.subscription_id)
+        }
+
+        if object.payment
+          case object.payment.method_details.type.downcase
+          when "card"
+            attrs[:payment_method_type] = "card"
+            attrs[:brand] = details.card.type
+            attrs[:exp_month] = details.card.expiry_month
+            attrs[:exp_year] = details.card.expiry_year
+            attrs[:last4] = details.card.last4
+          when "paypal"
+            attrs[:payment_method_type] = "paypal"
+          end
+
+          # Update customer's payment method
+          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
+        end
+
+        # Update or create the charge
+        if (pay_charge = pay_customer.charges.find_by(processor_id: object.id))
+          pay_charge.with_lock do
+            pay_charge.update!(attrs)
+          end
+          pay_charge
+        else
+          pay_customer.charges.create!(attrs.merge(processor_id: object.id))
+        end
+      end
+    end
+  end
+end