pay-whop 0.1.0.alpha.4

data/app/models/pay/whop/delivery.rb

@@ -0,0 +1,39 @@
+module Pay
+  module Whop
+    class Delivery < Pay::ApplicationRecord
+      self.table_name = "pay_whop_deliveries"
+
+      EVENTS = %w[payment.succeeded payment.failed payment.pending payment.canceled membership.activated membership.deactivated membership.updated refund.created refund.updated payment.authorized payment.requires_action setup_intent.succeeded setup_intent.canceled setup_intent.requires_action invoice.created invoice.paid invoice.past_due invoice.voided invoice.marked_uncollectible dispute.created dispute.updated transfer.created transfer.completed transfer.failed membership.cancel_at_period_end_changed account.updated payout.created payout.updated payout.reversed membership.trial_ending_soon].freeze
+
+      scope :pending, -> { where(processed_at: nil) }
+
+      def process!
+        return if processed_at?
+        unless environment == Whop.environment
+          raise IdentityError, "Webhook belongs to another Whop account or environment"
+        end
+        Whop.verify_account!({"account_id" => account_id})
+        case event_type
+        when /\Amembership\./
+          Subscription.sync(resource_id, account_id: account_id)
+        when "account.updated"
+          Merchant.sync(resource_id, account_id: account_id) unless resource_id == Whop.account_id
+        when /\Asetup_intent\./
+          PaymentMethod.sync_setup(resource_id, account_id: account_id)
+        when /\Ainvoice\./
+          Invoice.sync(resource_id, account_id: account_id)
+        when /\Adispute\./
+          Dispute.sync(resource_id, account_id: account_id)
+        when /\Apayout\./
+          Payout.sync(resource_id, account_id: account_id)
+        when /\Atransfer\./
+          Transfer.sync(resource_id, account_id: account_id)
+        else
+          Charge.sync(resource_id, account_id: account_id)
+        end
+        Pay::Webhooks.instrument(type: "whop.#{event_type}", event: {delivery: self})
+        update!(processed_at: Time.current)
+      end
+    end
+  end
+end

data/app/models/pay/whop/dispute.rb

@@ -0,0 +1,37 @@
+module Pay
+  module Whop
+    class Dispute < Resource
+      def self.sync(id, account_id:)
+        object = Whop.api_attributes(Whop.api.disputes.retrieve(id: id, request_options: Whop.request_options))
+        raise InvalidPayload, "Unexpected dispute ID" unless object.fetch("id") == id
+        Whop.verify_account!(object, expected: account_id)
+        payment_id = object.fetch("payment").fetch("id")
+        charge = Charge.sync(payment_id, account_id: account_id)
+        raise InvalidPayload, "Dispute payment is not a confirmed charge" unless charge
+        persist_snapshot(object, account_id: account_id, owner: charge.customer,
+          attributes: {currency: object["currency"], data: object.slice("reason", "evidence_due_at", "evidence_editable", "acceptable", "submission_failure_reason").merge("payment_id" => payment_id)})
+      end
+
+      def update_evidence(evidence:, idempotency_key: SecureRandom.uuid)
+        verify_configuration!
+        Whop.api.disputes.update(id: processor_id, evidence: evidence, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      def upload_evidence(documents:, idempotency_key: SecureRandom.uuid)
+        verify_configuration!
+        Whop.api.disputes.upload_evidence(id: processor_id, documents: documents,
+          request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      %i[submit accept].each do |operation|
+        define_method(operation) do |idempotency_key: SecureRandom.uuid|
+          verify_configuration!
+          Whop.api.disputes.public_send(operation, id: processor_id, request_options: Whop.request_options(idempotency_key: idempotency_key))
+          sync!
+        end
+      end
+    end
+  end
+end

data/app/models/pay/whop/entitlement.rb

@@ -0,0 +1,30 @@
+module Pay
+  module Whop
+    class Entitlement < Resource
+      def self.sync(id, account_id:)
+        object = Whop.api_attributes(Whop.api.memberships.retrieve(id: id, request_options: Whop.request_options))
+        raise InvalidPayload, "Unexpected membership ID" unless object.fetch("id") == id
+        sync_object(object, account_id: account_id)
+      end
+
+      def self.sync_object(object, account_id:)
+        Whop.verify_account!(object, expected: account_id)
+        raise InvalidPayload, "Recurring memberships are subscriptions" if object["renewal_price"].present?
+        customer = Customer.resolve!(object)
+        persist_snapshot(object, account_id: account_id, owner: customer,
+          attributes: {data: object.slice("product_id", "variant_id", "expires_at", "current_period_end", "manage_url")})
+      end
+
+      def active?
+        expiry = Whop.timestamp(data.to_h["expires_at"])
+        %w[completed active trialing].include?(status) && (expiry.nil? || expiry.future?)
+      end
+
+      def reactivate(days: nil, idempotency_key: SecureRandom.uuid)
+        verify_configuration!
+        Whop.api.memberships.reactivate(id: processor_id, days: days, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+    end
+  end
+end

data/app/models/pay/whop/invoice.rb

@@ -0,0 +1,61 @@
+module Pay
+  module Whop
+    class Invoice < Resource
+      def self.sync(id, account_id:)
+        object = Whop.api_attributes(Whop.api.invoices.retrieve(id: id, request_options: Whop.request_options))
+        raise InvalidPayload, "Unexpected invoice ID" unless object.fetch("id") == id
+        Whop.verify_account!(object, expected: account_id)
+        customer = Customer.resolve!(object)
+        total = object.fetch("total")
+        record = persist_snapshot(object, account_id: account_id, owner: customer, attributes: {
+          amount: Whop.minor_units(total), currency: total.fetch("currency"),
+          data: object.slice("checkout_link", "number", "due_at", "paid_at", "overdue", "membership_id")
+        })
+        Charge.sync(id, account_id: account_id) if object["status"] == "paid"
+        record
+      end
+
+      def checkout_url = data.to_h["checkout_link"]
+
+      def issue(charge_at: nil, idempotency_key: SecureRandom.uuid)
+        verify_configuration!
+        Whop.api.invoices.issue(id: processor_id, charge_at: charge_at&.iso8601, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      %i[void mark_uncollectible unschedule].each do |operation|
+        define_method(operation) do |idempotency_key: SecureRandom.uuid|
+          verify_configuration!
+          Whop.api.invoices.public_send(operation, id: processor_id, request_options: Whop.request_options(idempotency_key: idempotency_key))
+          sync!
+        end
+      end
+
+      def charge(payment_method_id: nil, idempotency_key: SecureRandom.uuid)
+        verify_configuration!
+        customer.add_payment_method(payment_method_id) if payment_method_id
+        Whop.api_request(:post, "invoices/#{ERB::Util.url_encode(processor_id)}/charge",
+          body: {payment_method_id: payment_method_id}.compact, idempotency_key: idempotency_key)
+        sync!
+      end
+
+      def deliver(idempotency_key: SecureRandom.uuid)
+        verify_configuration!
+        Whop.api.invoices.send_(id: processor_id, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      def update_details(memo: nil, due_at: nil, idempotency_key: SecureRandom.uuid)
+        verify_configuration!
+        Whop.api.invoices.update(id: processor_id, memo: memo, due_at: due_at&.iso8601,
+          request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      def pdf_url
+        verify_configuration!
+        Whop.api.invoices.generate_pdf(id: processor_id, request_options: Whop.request_options).url
+      end
+    end
+  end
+end

data/app/models/pay/whop/merchant.rb

@@ -0,0 +1,125 @@
+module Pay
+  module Whop
+    class Merchant < Pay::Merchant
+      has_many :transfers, class_name: "Pay::Whop::Transfer", dependent: :destroy
+      has_many :payouts, class_name: "Pay::Whop::Payout", dependent: :destroy
+
+      def self.registered?(account)
+        where(processor_id: account).any? { |merchant| merchant.configured? }
+      end
+
+      def configured?
+        data.to_h.values_at("whop_platform_id", "whop_environment") == [Whop.account_id, Whop.environment]
+      end
+
+      def verify_configuration!
+        raise IdentityError, "Merchant belongs to another platform or environment" unless configured? && processor_id.present?
+      end
+
+      def create_account(email:, title:, idempotency_key: "pay-whop-merchant-#{id}", **options)
+        return account if processor_id.present?
+        raise ArgumentError, "Unknown account option" unless (options.keys - %i[country website metadata send_customer_emails]).empty?
+        result = Whop.api.accounts.create(email: email, title: title, **options, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        object = Whop.api_attributes(Whop.api.accounts.retrieve(id: result.id, request_options: Whop.request_options))
+        raise IdentityError, "Account is not a child of this platform" unless object.dig("parent_account", "id") == Whop.account_id
+        with_lock do
+          raise IdentityError, "Merchant was already assigned" if processor_id.present? && processor_id != result.id
+          update!(processor_id: result.id, data: data.to_h.merge("whop_platform_id" => Whop.account_id, "whop_environment" => Whop.environment))
+        end
+        result
+      end
+
+      def account
+        verify_configuration!
+        result = Whop.api.accounts.retrieve(id: processor_id, request_options: Whop.request_options)
+        object = Whop.api_attributes(result)
+        unless object.fetch("id") == processor_id && object.dig("parent_account", "id") == Whop.account_id
+          raise IdentityError, "Account is not a child of this platform"
+        end
+        result
+      end
+
+      def self.sync(id, account_id:)
+        raise IdentityError, "Account event does not match its resource" unless [Whop.account_id, id].include?(account_id)
+        merchant = find_by!(processor_id: id)
+        object = Whop.api_attributes(merchant.account)
+        merchant.with_lock do
+          merchant.update!(data: merchant.data.to_h.merge("status" => object["status"], "capabilities" => object["capabilities"]))
+        end
+        merchant
+      end
+
+      def account_link(refresh_url:, return_url:, use_case: "account_onboarding", type: nil, idempotency_key: SecureRandom.uuid)
+        account
+        use_case = type if type
+        raise ArgumentError, "Invalid account link use case" unless %w[account_onboarding payouts_portal].include?(use_case)
+        Whop.api.account_links.create(account_id: processor_id, refresh_url: refresh_url, return_url: return_url,
+          use_case: use_case, request_options: Whop.request_options(idempotency_key: idempotency_key))
+      end
+
+      def login_link(refresh_url:, return_url:, **options)
+        account_link(refresh_url: refresh_url, return_url: return_url, use_case: "payouts_portal", **options)
+      end
+
+      def readiness
+        object = Whop.api_attributes(account)
+        {"status" => object["status"], "capabilities" => object["capabilities"],
+         "required_actions" => Array(object["required_actions"]).map { |action| action.slice("action", "status", "blocked_capabilities", "cta") }}
+      end
+
+      def capability_active?(name)
+        readiness.fetch("capabilities", {}).to_h[name.to_s] == "active"
+      end
+
+      def onboarding_complete?(capabilities: %w[accept_card_payments])
+        state = readiness
+        state["status"] == "active" && capabilities.present? && capabilities.all? { |name| state["capabilities"].to_h[name.to_s] == "active" }
+      end
+
+      def balance
+        verify_configuration!
+        object = Whop.api_request(:get, "ledger_accounts/#{ERB::Util.url_encode(processor_id)}")
+        raise IdentityError, "Ledger belongs to another account" unless object.dig("owner", "id") == processor_id
+        object.fetch("balances").map do |balance|
+          balance.slice("currency", "balance", "pending_balance", "reserve_balance").transform_values { |value| value.is_a?(Numeric) ? BigDecimal(value.to_s) : value }
+        end
+      end
+
+      def reconcile!
+        account
+        counts = {transfers: 0, payouts: 0}
+        Whop.each_api_page("transfers", origin_id: Whop.account_id, destination_id: processor_id) do |object|
+          unless object.dig("origin", "id") == Whop.account_id && object.dig("destination", "id") == processor_id
+            raise IdentityError, "Transfer belongs to another merchant"
+          end
+          Transfer.sync(object.fetch("id"), account_id: Whop.account_id)
+          counts[:transfers] += 1
+        end
+        Whop.each_api_page("payouts", account_id: processor_id) do |object|
+          Payout.sync_object(object, merchant: self)
+          counts[:payouts] += 1
+        end
+        counts
+      end
+
+      def customer_for(owner)
+        verify_configuration!
+        owner.with_lock do
+          existing = owner.pay_customers.where(type: "Pay::Whop::Customer", deleted_at: nil).detect { |customer| customer.account_id == processor_id && customer.data.to_h["whop_environment"] == Whop.environment }
+          existing || owner.pay_customers.create!(type: "Pay::Whop::Customer", processor: "whop", default: false,
+            data: {whop_account_id: processor_id, whop_environment: Whop.environment})
+        end
+      end
+
+      def transfer(amount:, idempotency_key:, currency: "usd", decimals: 2, metadata: {})
+        account
+        result = Whop.api.transfers.create(type: "balance", origin_id: Whop.account_id, destination_id: processor_id,
+          amount: Whop.major_units(amount, decimals: decimals), currency: currency, metadata: metadata,
+          idempotence_key: idempotency_key, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        Transfer.sync(result.id, account_id: Whop.account_id)
+      end
+
+      def whop? = true
+    end
+  end
+end

data/app/models/pay/whop/payment_method.rb

@@ -0,0 +1,41 @@
+module Pay
+  module Whop
+    class PaymentMethod < Pay::PaymentMethod
+      def self.sync(object, customer:)
+        customer.verify_configuration!
+        customer.with_lock do
+          method = customer.payment_methods.find_or_initialize_by(processor_id: object.fetch("id"))
+          method.update!(payment_method_type: object.fetch("payment_method_type"),
+            data: (object["card"] || {}).slice("brand", "last4", "exp_month", "exp_year"))
+          method
+        end
+      end
+
+      def make_default!
+        customer.verify_configuration!
+        customer.with_lock do
+          customer.payment_methods.update_all(default: false)
+          update!(default: true)
+        end
+      end
+
+      def detach
+        customer.sync_payment_methods
+        raise IdentityError, "Payment method is no longer owned by this customer" unless self.class.exists?(id)
+        Whop.api.payment_methods.delete_payment_method(id: processor_id, request_options: Whop.request_options(idempotency_key: "pay-whop-detach-#{id}"))
+        destroy!
+      end
+
+      def self.sync_setup(id, account_id:)
+        object = Whop.api_attributes(Whop.api.setup_intents.retrieve(id: id, request_options: Whop.request_options))
+        raise InvalidPayload, "Unexpected setup intent ID" unless object.fetch("id") == id
+        Whop.verify_account!(object, expected: account_id)
+        return unless object["status"] == "succeeded"
+        customer = Customer.resolve!(object)
+        customer.add_payment_method(object.fetch("payment_method_id"))
+      end
+
+      def whop? = true
+    end
+  end
+end

data/app/models/pay/whop/payout.rb

@@ -0,0 +1,39 @@
+module Pay
+  module Whop
+    class Payout < Resource
+      def self.sync(id, account_id:)
+        Whop.validate_configuration!
+        merchant = Merchant.find_by!(processor_id: account_id) unless account_id == Whop.account_id
+        merchant&.verify_configuration!
+        Whop.each_api_page("payouts", account_id: account_id) do |object|
+          return sync_object(object, merchant: merchant, account_id: account_id) if object.fetch("id") == id || object["payout_request_id"] == id
+        end
+        raise IdentityError, "Payout is not owned by this merchant"
+      end
+
+      def self.sync_object(object, merchant: nil, account_id: merchant&.processor_id || Whop.account_id)
+        Whop.validate_configuration!
+        merchant&.verify_configuration!
+        unless account_id == (merchant&.processor_id || Whop.account_id)
+          raise IdentityError, "Payout account is not registered"
+        end
+        if object["account_id"].present? && object["account_id"] != account_id
+          raise IdentityError, "Payout belongs to another account"
+        end
+        attributes = {currency: object["currency"], data: object.slice("amount", "fee_amount", "net_amount", "fee_paid_by", "payout_request_id", "estimated_arrival", "status_detail", "created_at")}
+        return persist_snapshot(object, account_id: account_id, owner: merchant, attributes: attributes) if merchant
+
+        record = create_or_find_by!(processor_id: object.fetch("id"), account_id: account_id, environment: Whop.environment) do |payout|
+          payout.assign_attributes(**attributes, status: object.fetch("status"))
+        end
+        record.with_lock do
+          raise IdentityError, "Platform payout has an unexpected owner" if record.customer_id || record.merchant_id
+          return record if record.status == "reversed" && object["status"] != "reversed"
+          return record if %w[completed reversed failed denied canceled].include?(record.status) && %w[requested in_review processing].include?(object["status"])
+          record.update!(**attributes, status: object.fetch("status"))
+        end
+        record
+      end
+    end
+  end
+end

data/app/models/pay/whop/resource.rb

@@ -0,0 +1,48 @@
+module Pay
+  module Whop
+    class Resource < Pay::ApplicationRecord
+      self.table_name = "pay_whop_resources"
+      belongs_to :customer, class_name: "Pay::Whop::Customer", optional: true
+      belongs_to :merchant, class_name: "Pay::Whop::Merchant", optional: true
+
+      def self.persist_snapshot(object, account_id:, owner:, attributes:)
+        raise IdentityError, "Resource account is not registered" unless Whop.verify_account!({"account_id" => account_id})
+        owner.with_lock do
+          record = find_or_initialize_by(processor_id: object.fetch("id"), account_id: account_id, environment: Whop.environment)
+          time = Whop.timestamp(object["updated_at"])
+          previous = Whop.timestamp(record.data.to_h["whop_updated_at"])
+          return record if time && previous && previous > time
+          if self == Transfer && record.persisted? && %w[succeeded failed].include?(record.status)
+            return record if object["status"] == "processing"
+            raise InvalidPayload, "Conflicting final transfer state" if object["status"] != record.status
+          end
+          if self == Payout && record.persisted? && %w[completed reversed failed denied canceled].include?(record.status)
+            return record if record.status == "reversed" && object["status"] != "reversed"
+            return record if %w[requested in_review processing].include?(object["status"])
+          end
+          owner_key = owner.is_a?(Merchant) ? :merchant : :customer
+          if record.persisted? && record.public_send("#{owner_key}_id") != owner.id
+            raise IdentityError, "Resource owner changed"
+          end
+          record.update!(**attributes, owner_key => owner, :status => object.fetch("status"),
+            :data => attributes.fetch(:data, {}).merge("whop_updated_at" => time&.iso8601(6)))
+          record
+        end
+      end
+
+      def verify_configuration!
+        raise IdentityError, "Resource belongs to another environment" unless environment == Whop.environment
+        Whop.verify_account!({"account_id" => account_id})
+        customer&.verify_configuration!
+        raise IdentityError, "Resource belongs to another customer account" if customer && customer.account_id != account_id
+        merchant&.verify_configuration!
+      end
+
+      def sync!
+        verify_configuration!
+        self.class.sync(processor_id, account_id: account_id)
+        reload
+      end
+    end
+  end
+end

data/app/models/pay/whop/subscription.rb

@@ -0,0 +1,180 @@
+module Pay
+  module Whop
+    class Subscription < Pay::Subscription
+      def self.sync(id, account_id: nil)
+        object = Whop.api_attributes(Whop.api.memberships.retrieve(id: id, request_options: Whop.request_options))
+        raise InvalidPayload, "Unexpected membership ID" unless object.fetch("id") == id
+        Whop.verify_account!(object, expected: account_id)
+        customer = Customer.resolve!(object)
+        unless object["renewal_price"].present?
+          Entitlement.sync_object(object, account_id: customer.account_id)
+          return
+        end
+        customer.with_lock do
+          record = customer.subscriptions.find_or_initialize_by(processor_id: id)
+          source_time = Whop.timestamp(object.fetch("updated_at"))
+          saved_time = Whop.timestamp(record.data.to_h["whop_updated_at"])
+          return record if saved_time && saved_time > source_time
+          status = object.fetch("status")
+          status = {"drafted" => "incomplete", "unresolved" => "incomplete", "canceling" => "active", "expired" => "canceled"}.fetch(status, status)
+          ends_at = if %w[canceled expired].include?(object["status"])
+            object["canceled_at"].presence || object["expires_at"].presence || object.fetch("updated_at")
+          elsif object["cancel_at_period_end"]
+            object.fetch("current_period_end")
+          end
+          record.update!(
+            name: record.name.presence || object.dig("metadata", "pay_subscription_name").presence || Pay.default_product_name,
+            processor_plan: object.fetch("variant_id"), quantity: 1, status: status,
+            pause_starts_at: (object["most_recent_action"] == "paused_at") ? Whop.timestamp(object["current_period_end"]) : nil,
+            current_period_start: Whop.timestamp(object["current_period_start"]),
+            current_period_end: Whop.timestamp(object["current_period_end"]),
+            trial_ends_at: (status == "trialing") ? Whop.timestamp(object["current_period_end"]) : nil,
+            ends_at: Whop.timestamp(ends_at),
+            data: record.data.to_h.merge("whop_updated_at" => source_time.iso8601(6), "manage_url" => object["manage_url"], "whop_billing_paused" => object["most_recent_action"] == "paused_at")
+          )
+          record
+        end
+      end
+
+      def sync!(**options)
+        customer.verify_configuration!
+        self.class.sync(processor_id, **options, account_id: customer.account_id)
+        reload
+      end
+
+      def api_record
+        customer.verify_configuration!
+        result = Whop.api.memberships.retrieve(id: processor_id, request_options: Whop.request_options)
+        customer.verify_resource!(Whop.api_attributes(result))
+        result
+      end
+
+      def portal_url = data.to_h["manage_url"]
+      def whop? = true
+      def paused? = data.to_h["whop_billing_paused"] == true
+
+      def active?
+        return super unless paused?
+        %w[active trialing].include?(status) && current_period_end.present? && current_period_end.future? && (ends_at.nil? || ends_at.future?)
+      end
+
+      def resumable? = paused? || (canceled? && on_grace_period?)
+
+      def cancel(idempotency_key: SecureRandom.uuid)
+        cancel_membership(true, idempotency_key)
+      end
+
+      def cancel_now!(idempotency_key: SecureRandom.uuid)
+        cancel_membership(false, idempotency_key)
+      end
+
+      def resume(idempotency_key: SecureRandom.uuid)
+        return unpause(idempotency_key: idempotency_key) if paused?
+        customer.verify_configuration!
+        raise Error, "Only a scheduled cancellation can be resumed" unless resumable?
+        Whop.api.memberships.update(id: processor_id, cancel_at_period_end: false, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      def pause(until_time: nil, idempotency_key: SecureRandom.uuid)
+        customer.verify_configuration!
+        Whop.api.memberships.pause(id: processor_id, until: until_time&.iso8601,
+          request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      def unpause(idempotency_key: SecureRandom.uuid)
+        customer.verify_configuration!
+        Whop.api.memberships.resume(id: processor_id, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      def reactivate(**options)
+        raise Pay::NotSupportedError, "Whop only reactivates one-time memberships; start a new checkout for an ended recurring subscription"
+      end
+
+      def extend_trial(days, idempotency_key: SecureRandom.uuid)
+        customer.verify_configuration!
+        raise ArgumentError, "Days must be between 1 and 1095" unless days.is_a?(Integer) && (1..1095).cover?(days)
+        Whop.api.memberships.extend_(id: processor_id, days: days, request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+      alias_method :add_free_days, :extend_trial
+
+      def update_payment_method(payment_method_id, idempotency_key: SecureRandom.uuid)
+        customer.add_payment_method(payment_method_id)
+        Whop.api.memberships.update(id: processor_id, payment_method_id: payment_method_id,
+          request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      def apply_promo_code(promo_code:, idempotency_key: SecureRandom.uuid)
+        customer.verify_configuration!
+        Whop.api.memberships.apply_promo_code(id: processor_id, promo_code: promo_code,
+          request_options: Whop.request_options(idempotency_key: idempotency_key))
+        sync!
+      end
+
+      def latest_payment
+        api_record
+        payment = Whop.api.payments.list(account_id: customer.account_id, member_id: customer.processor_id,
+          membership_id: processor_id, order: "created_at", direction: "desc", first: 1, request_options: Whop.request_options).first
+        return unless payment
+        object = Whop.api_attributes(payment)
+        customer.verify_resource!(object)
+        raise IdentityError, "Payment belongs to another membership" unless object["membership_id"] == processor_id
+        customer.payment(object.fetch("id"))
+      end
+
+      def retry_failed_payment(payment_id: nil, idempotency_key: SecureRandom.uuid)
+        payment = payment_id ? customer.payment(payment_id) : latest_payment
+        raise Error, "No membership payment is available to retry" unless payment
+        object = Whop.api_attributes(payment)
+        raise IdentityError, "Payment belongs to another membership" unless object["membership_id"] == processor_id
+        return Charge.sync(payment.id, account_id: customer.account_id) if payment.status == "paid"
+        customer.retry_payment(payment.id, idempotency_key: idempotency_key)
+      end
+
+      def reduce_renewal_price(amount, decimals: nil, idempotency_key: SecureRandom.uuid)
+        object = Whop.api_attributes(api_record)
+        price = object.fetch("renewal_price")
+        precision = price.fetch("decimals")
+        raise ArgumentError, "Precision must match the renewal currency" if decimals && decimals != precision
+        value = Whop.major_units(amount, decimals: precision)
+        raise ArgumentError, "Renewal price can only be reduced" unless amount < Whop.minor_units(price)
+        update_renewal({renewal_price: value}, idempotency_key)
+      end
+
+      def change_billing_period(days, idempotency_key: SecureRandom.uuid)
+        raise ArgumentError, "Billing period must be between 1 and 365 days" unless days.is_a?(Integer) && (1..365).cover?(days)
+        api_record
+        update_renewal({billing_period_days: days}, idempotency_key)
+      end
+
+      def change_next_renewal(at, idempotency_key: SecureRandom.uuid)
+        raise ArgumentError, "Next renewal must be after today in UTC" unless at.respond_to?(:utc) && at.utc.to_date > Time.current.utc.to_date
+        api_record
+        update_renewal({current_period_end: at.utc.iso8601}, idempotency_key)
+      end
+
+      %i[swap change_quantity].each do |operation|
+        define_method(operation) do |*args, **options|
+          raise Pay::NotSupportedError, "#{operation} is not supported by pay-whop yet"
+        end
+      end
+
+      private
+
+      def update_renewal(attributes, key)
+        Whop.api_request(:patch, "memberships/#{ERB::Util.url_encode(processor_id)}", body: attributes, idempotency_key: key)
+        sync!
+      end
+
+      def cancel_membership(at_period_end, key)
+        customer.verify_configuration!
+        Whop.api.memberships.cancel(id: processor_id, cancel_at_period_end: at_period_end, request_options: Whop.request_options(idempotency_key: key))
+        sync!
+      end
+    end
+  end
+end

data/app/models/pay/whop/transfer.rb

@@ -0,0 +1,20 @@
+module Pay
+  module Whop
+    class Transfer < Resource
+      def self.sync(id, account_id:)
+        object = Whop.api_attributes(Whop.api.transfers.retrieve(id: id, request_options: Whop.request_options))
+        raise InvalidPayload, "Unexpected transfer ID" unless object.fetch("id") == id
+        destination = object.fetch("destination").fetch("id")
+        unless object.dig("origin", "id") == Whop.account_id && [Whop.account_id, destination].include?(account_id)
+          raise IdentityError, "Transfer is outside this platform"
+        end
+        merchant = Merchant.find_by!(processor_id: destination)
+        merchant.verify_configuration!
+        total = object["amount"].presence
+        persist_snapshot(object, account_id: Whop.account_id, owner: merchant,
+          attributes: {amount: total && Whop.minor_units(total), currency: total && total.fetch("currency"),
+                       data: {"origin_id" => Whop.account_id, "destination_id" => destination}})
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Pay::Whop::Engine.routes.draw do
+  post "webhooks", to: "pay/whop/webhooks#create"
+end

data/db/migrate/20261107000000_create_pay_whop_deliveries.rb

@@ -0,0 +1,15 @@
+class CreatePayWhopDeliveries < ActiveRecord::Migration[7.0]
+  def change
+    create_table :pay_whop_deliveries do |t|
+      t.string :event_id, null: false
+      t.string :event_type, null: false
+      t.string :resource_id, null: false
+      t.string :account_id, null: false
+      t.string :environment, null: false
+      t.datetime :processed_at
+      t.timestamps
+    end
+    add_index :pay_whop_deliveries, [:environment, :account_id, :event_id], unique: true, name: "pay_whop_delivery_identity"
+    add_index :pay_whop_deliveries, :processed_at
+  end
+end