lipwa 0.1.2 → 0.1.3

data/lib/lipwa/gateways/paystack.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "../gateway"
+require_relative "../gateways"
+require_relative "../capabilities/purchase"
+require_relative "../capabilities/authorize"
+require_relative "../capabilities/capture"
+require_relative "../capabilities/void"
+
+module Lipwa
+  module Gateways
+    # Paystack hosted card payments. Paystack captures card payments in its
+    # checkout flow, so capture verifies the transaction and void refunds it.
+    class Paystack < Lipwa::Gateway
+      include Lipwa::Capabilities::Purchase
+      include Lipwa::Capabilities::Authorize
+      include Lipwa::Capabilities::Capture
+      include Lipwa::Capabilities::Void
+
+      BASE_URL = "https://api.paystack.co"
+      INITIALIZE_PATH = "/transaction/initialize"
+      VERIFY_PATH = "/transaction/verify"
+      REFUND_PATH = "/refund"
+      SUBUNIT_FACTOR = 100
+
+      setting :secret_key
+
+      private
+
+      def perform_purchase(params, idempotency_key) = initialize_transaction(params, idempotency_key)
+      def perform_authorize(params, idempotency_key) = initialize_transaction(params, idempotency_key)
+
+      def perform_capture(params, idempotency_key)
+        response = http.get("#{VERIFY_PATH}/#{params[:authorization]}", idempotency_key: idempotency_key)
+        build_response(response.body, fallback_reference: params[:authorization], require_completed: true)
+      rescue Lipwa::GatewayError => e
+        Failure(e)
+      end
+
+      def perform_void(params, idempotency_key)
+        response = http.post(REFUND_PATH, body: { transaction: params[:authorization] },
+                                          idempotency_key: idempotency_key)
+        build_response(response.body, fallback_reference: params[:authorization])
+      rescue Lipwa::GatewayError => e
+        Failure(e)
+      end
+
+      def initialize_transaction(params, idempotency_key)
+        email = address_value(params[:billing_address], :email_address)
+        return Failure(Lipwa::GatewayError.new("billing_address email_address is required by Paystack")) unless email
+
+        response = http.post(INITIALIZE_PATH, body: initialize_body(params, email),
+                                              idempotency_key: idempotency_key)
+        build_response(response.body, fallback_reference: params[:reference])
+      rescue Lipwa::GatewayError => e
+        Failure(e)
+      end
+
+      def initialize_body(params, email)
+        {
+          email: email,
+          amount: paystack_amount(params[:amount]),
+          currency: params[:amount].currency,
+          reference: params[:reference],
+          callback_url: params[:callback_url],
+          channels: ["card"],
+          metadata: { description: params[:description], notification_id: params[:notification_id] }
+        }
+      end
+
+      def paystack_amount(money)
+        subunits = money.amount * SUBUNIT_FACTOR
+        raise Lipwa::GatewayError, "amount must resolve to a whole Paystack subunit" unless subunits.frac.zero?
+
+        subunits.to_i
+      end
+
+      def address_value(address, key) = address[key] || address[key.to_s]
+
+      def build_response(body, fallback_reference:, require_completed: false)
+        data = body["data"].is_a?(Hash) ? body["data"] : {}
+        Success(Lipwa::Response.new(
+                  success: response_successful?(body, data, require_completed),
+                  provider_reference: (data["reference"] || fallback_reference)&.to_s,
+                  message: body["message"] || data["status"],
+                  code: (data["status"] || body["status"])&.to_s,
+                  raw: body
+                ))
+      end
+
+      def response_successful?(body, data, require_completed)
+        return false unless body["status"] == true
+        return true unless require_completed
+
+        data["status"].to_s.casecmp?("success")
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def build_http_adapter
+        config = self.config
+        ensure_paystack_config_present!(config)
+        auth = config.auth_strategy || AuthStrategies::BearerToken.new(-> { config.secret_key })
+        HttpAdapter.new(base_url: config.base_url || BASE_URL, auth_strategy: auth,
+                        timeout: config.timeout || global_config.default_timeout,
+                        open_timeout: config.open_timeout, logger: config.logger || global_config.logger,
+                        adapter: global_config.adapter)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def ensure_paystack_config_present!(config)
+        return if config.auth_strategy || config.secret_key
+
+        raise Lipwa::ConfigurationError, "#{self.class} is missing secret_key — set it via .configure"
+      end
+    end
+  end
+end
+
+Lipwa::Gateways.register(:paystack, Lipwa::Gateways::Paystack)

data/lib/lipwa/gateways/pesapal/auth.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require_relative "../../errors"
+
+module Lipwa
+  module Gateways
+    class Pesapal
+      # Fetches and briefly caches Pesapal API bearer tokens.
+      class Auth
+        TOKEN_PATH = "/api/Auth/RequestToken"
+
+        def initialize(consumer_key:, consumer_secret:, base_url:, clock: -> { Time.now })
+          @consumer_key = consumer_key
+          @consumer_secret = consumer_secret
+          @base_url = base_url
+          @clock = clock
+          @mutex = Mutex.new
+        end
+
+        def initialize_copy(source)
+          super
+          @token = nil
+          @expires_at = nil
+          @mutex = Mutex.new
+        end
+
+        def inspect
+          "#<#{self.class}:0x#{object_id.to_s(16)}>"
+        end
+
+        def call
+          return @token if @token && @expires_at && @clock.call < @expires_at
+
+          @mutex.synchronize do
+            fetch_token unless @token && @expires_at && @clock.call < @expires_at
+          end
+
+          @token
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def fetch_token
+          response = Faraday.post("#{@base_url}#{TOKEN_PATH}") do |request|
+            request.headers["Accept"] = "application/json"
+            request.headers["Content-Type"] = "application/json"
+            request.body = JSON.generate(consumer_key: @consumer_key, consumer_secret: @consumer_secret)
+          end
+          body = JSON.parse(response.body)
+          token = body["token"]
+          raise_auth_error(response, body) unless response.success? && token
+
+          @token = token
+          @expires_at = @clock.call + 270
+          @token
+        rescue Faraday::Error, JSON::ParserError => e
+          raise Lipwa::GatewayError.new("Pesapal authentication failed: #{e.message}", raw: e)
+        end
+
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+        def raise_auth_error(response, body)
+          error = body["error"].is_a?(Hash) ? body["error"] : {}
+          message = error["message"] || body["message"] || "Pesapal authentication failed"
+          raise Lipwa::GatewayError.new(message, code: (error["code"] || response.status).to_s, raw: body)
+        end
+      end
+    end
+  end
+end

data/lib/lipwa/gateways/pesapal.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "../gateway"
+require_relative "../gateways"
+require_relative "../capabilities/purchase"
+require_relative "../capabilities/authorize"
+require_relative "../capabilities/capture"
+require_relative "../capabilities/void"
+
+module Lipwa
+  module Gateways
+    # Pesapal API 3.0 hosted-checkout gateway.
+    class Pesapal < Lipwa::Gateway
+      include Lipwa::Capabilities::Purchase
+      include Lipwa::Capabilities::Authorize
+      include Lipwa::Capabilities::Capture
+      include Lipwa::Capabilities::Void
+
+      BASE_URLS = {
+        sandbox: "https://cybqa.pesapal.com/pesapalv3",
+        production: "https://pay.pesapal.com/v3"
+      }.freeze
+      SUBMIT_ORDER_PATH = "/api/Transactions/SubmitOrderRequest"
+      STATUS_PATH = "/api/Transactions/GetTransactionStatus"
+      CANCEL_PATH = "/api/Transactions/CancelOrder"
+
+      setting :consumer_key
+      setting :consumer_secret
+      setting :clock
+
+      private
+
+      def perform_purchase(params, idempotency_key) = submit_order(params, idempotency_key)
+      def perform_authorize(params, idempotency_key) = submit_order(params, idempotency_key)
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def perform_capture(params, idempotency_key)
+        response = http.get(STATUS_PATH, params: { orderTrackingId: params[:authorization] },
+                                         idempotency_key: idempotency_key)
+        body = response.body
+        completed = body["payment_status_description"].to_s.casecmp?("COMPLETED") ||
+                    body["status_code"].to_i == 1
+        Success(Lipwa::Response.new(
+                  success: completed,
+                  provider_reference: body["confirmation_code"] || params[:authorization],
+                  message: body["payment_status_description"] || pesapal_message(body),
+                  code: (body["status_code"] || body["status"])&.to_s,
+                  raw: body
+                ))
+      rescue Lipwa::GatewayError => e
+        Failure(e)
+      end
+
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      def perform_void(params, idempotency_key)
+        response = http.post(CANCEL_PATH, body: { order_tracking_id: params[:authorization] },
+                                          idempotency_key: idempotency_key)
+        build_response(response.body, fallback_reference: params[:authorization])
+      rescue Lipwa::GatewayError => e
+        Failure(e)
+      end
+
+      def submit_order(params, idempotency_key)
+        response = http.post(SUBMIT_ORDER_PATH, body: order_body(params), idempotency_key: idempotency_key)
+        build_response(response.body)
+      rescue Lipwa::GatewayError => e
+        Failure(e)
+      end
+
+      def order_body(params)
+        {
+          id: params[:reference], currency: params[:amount].currency, amount: params[:amount].amount,
+          description: params[:description], callback_url: params[:callback_url],
+          notification_id: params[:notification_id], billing_address: params[:billing_address],
+          cancellation_url: params[:cancellation_url], redirect_mode: params[:redirect_mode],
+          branch: params[:branch]
+        }.compact
+      end
+
+      def build_response(body, fallback_reference: nil)
+        status = body["status"].to_s
+        error = pesapal_error(body)
+        Success(Lipwa::Response.new(
+                  success: error.empty? && status.start_with?("2"),
+                  provider_reference: body["order_tracking_id"] || fallback_reference,
+                  message: body["message"] || error["message"],
+                  code: status.empty? ? error["code"]&.to_s : status,
+                  raw: body
+                ))
+      end
+
+      def pesapal_error(body) = body["error"].is_a?(Hash) ? body["error"] : {}
+      def pesapal_message(body) = pesapal_error(body)["message"]
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def build_http_adapter
+        config = self.config
+        ensure_pesapal_config_present!(config)
+        base_url = config.base_url || BASE_URLS.fetch(config.env)
+        auth = config.auth_strategy || AuthStrategies::BearerToken.new(
+          Auth.new(consumer_key: config.consumer_key, consumer_secret: config.consumer_secret,
+                   base_url: base_url, clock: config.clock || -> { Time.now })
+        )
+        HttpAdapter.new(base_url: base_url, auth_strategy: auth,
+                        timeout: config.timeout || global_config.default_timeout,
+                        open_timeout: config.open_timeout, logger: config.logger || global_config.logger,
+                        adapter: global_config.adapter)
+      end
+
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      def ensure_pesapal_config_present!(config)
+        return if config.auth_strategy || (config.consumer_key && config.consumer_secret)
+
+        raise Lipwa::ConfigurationError,
+              "#{self.class} is missing consumer_key/consumer_secret — set them via .configure"
+      end
+    end
+  end
+end
+
+require_relative "pesapal/auth"
+
+Lipwa::Gateways.register(:pesapal, Lipwa::Gateways::Pesapal)

data/lib/lipwa/gateways.rb

@@ -18,7 +18,13 @@ module Lipwa
           raise Lipwa::ConfigurationError, "#{gateway_class} must be a subclass of Lipwa::Gateway"
         end
 
-        super(key.to_sym, memoize: true) { gateway_class.new }
+        super(key.to_sym, memoize: true) { gateway_class.new }.tap do
+          (@gateway_classes ||= {})[key.to_s] = gateway_class
+        end
+      end
+
+      def gateway_classes
+        (@gateway_classes || {}).dup
       end
     end
   end

data/lib/lipwa/http_adapter.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
 require "faraday"
 require "faraday/retry"
+require "json"
 require_relative "errors"
 require_relative "auth_strategies"
+require_relative "logging"
 
 module Lipwa
   # Thin wrapper around Faraday shared by every gateway's HTTP calls:
@@ -12,17 +15,28 @@ module Lipwa
   # bearer tokens (M-Pesa, Co-op) and request-signing (Jenga) plug into
   # the same request path without HttpAdapter knowing which is which.
   class HttpAdapter
+    IDEMPOTENCY_HEADER = "Idempotency-Key"
+    RETRYABLE_METHODS = %i[get head options].freeze
+    RETRYABLE_STATUSES = [429, 500, 502, 503, 504].freeze
+    RETRYABLE_EXCEPTIONS = Faraday::Retry::Middleware::DEFAULT_EXCEPTIONS.freeze
+    RETRY_IF_IDEMPOTENT = lambda do |env, _exception|
+      value = env.request_headers[IDEMPOTENCY_HEADER]
+      !value.nil? && !value.empty?
+    end
+
     DEFAULT_RETRY_OPTIONS = {
       max: 2,
       interval: 0.5,
       interval_randomness: 0.5,
       backoff_factor: 2,
-      retry_statuses: [429, 500, 502, 503, 504],
-      methods: %i[get post put patch delete],
-      exceptions: Faraday::Retry::Middleware::DEFAULT_EXCEPTIONS
+      max_interval: 5,
+      retry_statuses: RETRYABLE_STATUSES,
+      methods: RETRYABLE_METHODS,
+      exceptions: RETRYABLE_EXCEPTIONS,
+      retry_if: RETRY_IF_IDEMPOTENT
     }.freeze
 
-    attr_reader :base_url, :auth_strategy, :timeout, :open_timeout, :logger, :adapter
+    attr_reader :base_url, :auth_strategy, :timeout, :open_timeout, :logger, :adapter, :retry_options
 
     # rubocop:disable Metrics/ParameterLists
     def initialize(base_url:, auth_strategy: AuthStrategies::None.new, timeout: 10,
@@ -33,22 +47,28 @@ module Lipwa
       @timeout = timeout
       @open_timeout = open_timeout
       @logger = logger
-      @retry_options = DEFAULT_RETRY_OPTIONS.merge(retry_options)
+      @retry_options = DEFAULT_RETRY_OPTIONS.merge(retry_options).freeze
       @stubs = stubs
       @adapter = adapter
     end
     # rubocop:enable Metrics/ParameterLists
 
-    def get(path, params: {}, headers: {})
-      request(:get, path, params: params, headers: headers)
+    def get(path, params: {}, headers: {}, idempotency_key: nil)
+      request(:get, path, params: params, headers: idempotency_headers(headers, idempotency_key))
+    end
+
+    def post(path, body: nil, params: {}, headers: {}, idempotency_key: nil)
+      request(:post, path, body: body, params: params, headers: idempotency_headers(headers, idempotency_key))
     end
 
-    def post(path, body: nil, params: {}, headers: {})
-      request(:post, path, body: body, params: params, headers: headers)
+    def put(path, body: nil, params: {}, headers: {}, idempotency_key: nil)
+      request(:put, path, body: body, params: params, headers: idempotency_headers(headers, idempotency_key))
     end
 
-    def put(path, body: nil, params: {}, headers: {})
-      request(:put, path, body: body, params: params, headers: headers)
+    # Auth strategies may own API keys or OAuth clients. Avoid recursively
+    # exposing them through the adapter's default instance-variable dump.
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}>"
     end
 
     private
@@ -65,7 +85,28 @@ module Lipwa
       req.url(path)
       req.params.update(params) if params && !params.empty?
       req.headers.update(headers)
-      req.body = body if body
+      req.body = json_safe_decimals(body) if body
+    end
+
+    def idempotency_headers(headers, idempotency_key)
+      return headers unless idempotency_key
+
+      headers.merge(IDEMPOTENCY_HEADER => idempotency_key)
+    end
+
+    # JSON otherwise encodes BigDecimal as a quoted scientific-notation string.
+    # A fragment preserves the exact base-10 value as a JSON number.
+    def json_safe_decimals(value)
+      case value
+      when BigDecimal
+        JSON::Fragment.new(value.to_s("F"))
+      when Hash
+        value.transform_values { |item| json_safe_decimals(item) }
+      when Array
+        value.map { |item| json_safe_decimals(item) }
+      else
+        value
+      end
     end
 
     def connection
@@ -77,17 +118,15 @@ module Lipwa
     end
 
     def configure_middleware(conn)
-      conn.request :retry, @retry_options
+      conn.request :retry, retry_options
       conn.request :json
       conn.response :json, content_type: /\bjson$/
-      configure_logger(conn) if logger
       conn.use AuthMiddleware, auth_strategy
+      configure_logger(conn) if logger
     end
 
     def configure_logger(conn)
-      conn.response :logger, logger, headers: true, bodies: true do |l|
-        l.filter(/(Authorization: )(.+)/, '\1[REDACTED]')
-      end
+      conn.use Logging::Middleware, logger
     end
 
     def configure_timeouts(conn)

data/lib/lipwa/logging.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Lipwa
+  module Logging
+    REDACTED = "[REDACTED]"
+
+    # Produces sanitized copies of nested payloads without mutating caller data.
+    module Redactor
+      SECRET_NAMES = "authorization|signature|cookie|api[_-]?key|access[_-]?token|" \
+                     "refresh[_-]?token|token|consumer[_-]?key|client[_-]?id|" \
+                     "secret|password|passkey|" \
+                     "security[_-]?credential|private[_-]?key|admin[_-]?key|invoice[_-]?key|encryption[_-]?key"
+      SENSITIVE_KEY = /(?:#{SECRET_NAMES})/i
+      STRING_PATTERNS = [
+        /((?:authorization|proxy-authorization|signature)\s*:\s*)[^\r\n,]+/i,
+        /((?:^|[?&])(?:#{SECRET_NAMES})=)[^&#\s]+/i,
+        /(["']?(?:#{SECRET_NAMES})["']?\s*[:=]\s*["'])[^"']*(["'])/i
+      ].freeze
+
+      module_function
+
+      def call(value, key: nil) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        return REDACTED if sensitive_key?(key)
+
+        case value
+        when Hash
+          value.each_with_object({}) do |(child_key, child_value), copy|
+            copy[child_key] = call(child_value, key: child_key)
+          end
+        when Array then value.map { |item| call(item) }
+        when String then redact_string(value)
+        when Exception then { class: value.class.name, message: redact_string(value.message) }
+        else value
+        end
+      end
+
+      def sensitive_key?(key) = key&.to_s&.match?(SENSITIVE_KEY)
+
+      def redact_string(value)
+        STRING_PATTERNS.reduce(value.dup) do |redacted, pattern|
+          redacted.gsub(pattern) { "#{Regexp.last_match(1)}#{REDACTED}#{Regexp.last_match(2)}" }
+        end
+      end
+    end
+
+    # Faraday middleware that emits one structured, sanitized event per call.
+    class Middleware < Faraday::Middleware
+      def initialize(app, logger)
+        super(app)
+        @logger = logger
+      end
+
+      def call(env)
+        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @app.call(env).on_complete { |completed| log(completed, started_at) }
+      rescue StandardError => e
+        log(env, started_at, error: e)
+        raise
+      end
+
+      private
+
+      def log(env, started_at, error: nil) # rubocop:disable Metrics/AbcSize
+        event = {
+          event: "lipwa.http", method: env.method&.to_s&.upcase,
+          url: sanitized_url(env.url), status: env.status,
+          duration_ms: elapsed_ms(started_at),
+          request: { headers: Redactor.call(env.request_headers.to_h), body: redact_body(env.request_body) },
+          response: { headers: Redactor.call(env.response_headers.to_h), body: redact_body(env.response_body) }
+        }
+        event[:error] = Redactor.call(error) if error
+        @logger.public_send(error || env.status.to_i >= 400 ? :error : :info, event)
+      end
+
+      def sanitized_url(url)
+        return unless url
+
+        copy = url.dup
+        copy.user = REDACTED if copy.user
+        copy.password = REDACTED if copy.password
+        copy.query = Redactor.redact_string(copy.query) if copy.query
+        copy.to_s
+      end
+
+      def redact_body(body)
+        parsed = body.is_a?(String) ? JSON.parse(body) : body
+        Redactor.call(parsed)
+      rescue JSON::ParserError
+        Redactor.call(body)
+      end
+
+      def elapsed_ms(started_at)
+        ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(1)
+      end
+    end
+  end
+end

data/lib/lipwa/money.rb

@@ -4,10 +4,10 @@ require "dry/struct"
 require_relative "types"
 
 module Lipwa
-  # Immutable representation of an amount in minor currency units.
-  # KES has no subunit in practice, but we keep minor units as the
-  # storage form so other currencies fit the same shape later.
+  # Immutable, decimal representation of an amount in one currency.
   class Money < Dry::Struct
+    include Comparable
+
     attribute :amount, Types::Amount
     attribute :currency, Types::Currency.default("KES")
 
@@ -21,16 +21,45 @@ module Lipwa
       self.class.new(amount: amount - other.amount, currency: currency)
     end
 
+    def *(other)
+      self.class.new(amount: amount * decimal_scalar(other), currency: currency)
+    end
+
+    def /(other)
+      divisor = decimal_scalar(other)
+      raise ZeroDivisionError, "divided by 0" if divisor.zero?
+
+      self.class.new(amount: amount / divisor, currency: currency)
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+
+      assert_same_currency!(other)
+      amount <=> other.amount
+    end
+
+    def zero?
+      amount.zero?
+    end
+
     def to_s
-      "#{amount} #{currency}"
+      "#{amount.to_s("F")} #{currency}"
     end
 
     private
 
     def assert_same_currency!(other)
+      raise TypeError, "expected #{self.class}, got #{other.class}" unless other.is_a?(self.class)
       return if currency == other.currency
 
       raise ArgumentError, "currency mismatch: #{currency} vs #{other.currency}"
     end
+
+    def decimal_scalar(value)
+      Types::Coercible::Decimal[value]
+    rescue Dry::Types::CoercionError, Dry::Types::ConstraintError
+      raise TypeError, "expected a numeric scalar, got #{value.inspect}"
+    end
   end
 end

data/lib/lipwa/types.rb

@@ -7,9 +7,9 @@ module Lipwa
   module Types
     include Dry.Types()
 
-    # Amounts are always integers in minor currency units (e.g. cents,
-    # or whole KES since M-Pesa has no subunit) to avoid float math.
-    Amount = Types::Strict::Integer.constrained(gteq: 0)
+    # BigDecimal-backed amounts avoid binary floating-point errors while
+    # accepting the numeric and string inputs commonly received from APIs.
+    Amount = Types::Coercible::Decimal.constrained(gteq: 0)
 
     Currency = Types::Strict::String.constrained(format: /\A[A-Z]{3}\z/)
 

data/lib/lipwa/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lipwa
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/lipwa/webhooks/coop_bank.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../webhook"
+
+module Lipwa
+  module Webhooks
+    # Normalizes Co-op Bank transaction callbacks into WebhookEvent.
+    module CoopBank
+      module_function
+
+      def call(body:, headers: {}) # rubocop:disable Lint/UnusedMethodArgument
+        payload = body.is_a?(String) ? JSON.parse(body) : body
+        code = payload["MessageCode"]
+
+        Lipwa::WebhookEvent.new(
+          provider: :coop_bank,
+          event_type: :transaction_status,
+          success: code.to_s == "0",
+          provider_reference: payload["MessageReference"]&.to_s,
+          message: payload["MessageDescription"]&.to_s,
+          raw: payload
+        )
+      end
+    end
+  end
+end
+
+Lipwa::Webhook.register(:coop_bank, Lipwa::Webhooks::CoopBank)