payhub 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df642ff56742eb5ad6bb7fc16383d398ae07fc9ade7c43a3d8d0cc66a9c40e4b
+  data.tar.gz: ba44c24e7fa075789e8d7ec1135be1ce725d006bebc9e135583d0d7a948a9eb8
+SHA512:
+  metadata.gz: 1405e7530c8962ffcf8b617e304c418d8e7f03d538cf432250d98bf2c945490f441a93f6c0cbd114fdf1aefa04c7c9e409f48b663d4bda94273a88ed75804d0e
+  data.tar.gz: e8c98a274bd6e72ffa5992df693b6716c94a4a30f9ed9d11a430d90e84785cde7967667fd6d3eaa8aae5ab60453d63070a97142c1dd2bac9e805f0205d2fe96d

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Safwa Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,102 @@
+# PayHub Ruby SDK
+
+Official PayHub SDK for Ruby. Synchronous Net::HTTP transport, idempotent
+retries, typed error hierarchy, webhook verifier, and a discriminated
+`NextAction` you `case`-match on.
+
+## Install
+
+```bash
+gem install payhub
+```
+
+Or in `Gemfile`:
+
+```ruby
+gem "payhub", "~> 1.0"
+```
+
+## Quickstart — Sadad OTP
+
+```ruby
+require "payhub"
+
+client = Payhub::Client.new(ENV.fetch("PAYHUB_API_KEY"))
+
+payment = client.payments.create(
+  psp: "sadad",
+  merchant_order_ref: "ord-42",
+  amount_minor: 4500,
+  currency: "LYD",
+  customer: {msisdn: "218910000001", birth_year: 1990}
+)
+
+case payment.next_action
+in Payhub::NextAction::OtpRequired => otp
+  puts "Sadad sent OTP to #{otp.masked_destination}"
+end
+
+confirmed = client.payments.confirm_otp(payment.id, "111111")
+puts confirmed.status # "succeeded"
+```
+
+## Webhook verification (Rails / Sinatra / Rack)
+
+The single most important rule: **verify the raw request body**, not a
+parsed Hash. Re-serializing the JSON before HMAC will corrupt the signature.
+
+```ruby
+# Rack / Sinatra
+post "/webhooks/payhub" do
+  body = request.body.read
+
+  ev = Payhub::WebhookEvent.verify(
+    secret: ENV.fetch("PAYHUB_WEBHOOK_SECRET"),
+    body: body,
+    header: request.env["HTTP_HUB_SIGNATURE"]
+  )
+
+  # ev.type ∈ "payment.succeeded" | "payment.failed" | "payment.expired" | "payment.refunded"
+  status 200
+end
+```
+
+```ruby
+# Rails controller
+class WebhooksController < ApplicationController
+  skip_before_action :verify_authenticity_token
+
+  def payhub
+    body = request.raw_post
+    ev = Payhub::WebhookEvent.verify(
+      ENV.fetch("PAYHUB_WEBHOOK_SECRET"),
+      body,
+      request.headers["Hub-Signature"]
+    )
+    head :ok
+  end
+end
+```
+
+## Errors
+
+| Class | When |
+| --- | --- |
+| `Payhub::Errors::AuthenticationError` | 401 |
+| `Payhub::Errors::PermissionError` | 403 |
+| `Payhub::Errors::NotFoundError` | 404 |
+| `Payhub::Errors::IdempotencyConflictError` | 409 |
+| `Payhub::Errors::ValidationError` | 422 |
+| `Payhub::Errors::RateLimitedError` | 429 (`#retry_after`) |
+| `Payhub::Errors::GatewayError` | 5xx + `gateway.<psp>.*` |
+| `Payhub::Errors::ServerError` | other 5xx |
+| `Payhub::Errors::TimeoutError` | timeout |
+| `Payhub::Errors::ConnectionError` | TCP / TLS / DNS failure |
+| `Payhub::Errors::DecodeError` | malformed response |
+| `Payhub::MalformedHeaderError` | webhook header missing `t=`/`v1=` |
+| `Payhub::TimestampOutOfToleranceError` | webhook clock skew > 300 s |
+| `Payhub::InvalidSignatureError` | webhook HMAC mismatch |
+
+## License
+
+MIT — see `LICENSE`.

data/lib/payhub/client.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "securerandom"
+require "uri"
+require "rbconfig"
+
+require_relative "errors"
+require_relative "types"
+require_relative "version"
+
+module Payhub
+  # Synchronous PayHub client. Thread-safe — share one instance per process;
+  # internally each request opens a fresh Net::HTTP connection (keep-alive
+  # is delegated to the OS-level connection pool of the HTTP server tier).
+  class Client
+    DEFAULT_BASE_URL = "https://app.payhub.ly"
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_RETRIES = 2
+
+    attr_reader :payments, :health
+
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT,
+      max_retries: DEFAULT_RETRIES, http_client: nil, user_agent_suffix: nil)
+      raise ArgumentError, "PayHub API key must start with 'phk_'" unless api_key.is_a?(String) && api_key.start_with?("phk_")
+      @api_key = api_key
+      @base_url = base_url.sub(%r{/+$}, "")
+      @timeout = timeout
+      @max_retries = max_retries
+      @http_client = http_client
+      @user_agent = build_user_agent(user_agent_suffix)
+      @payments = Payments.new(self)
+      @health = HealthResource.new(self)
+    end
+
+    # Internal request helper used by resource classes.
+    def request(method, path, body: nil, idempotency_key: nil, retriable: true)
+      attempts = retriable ? [@max_retries + 1, 1].max : 1
+      last_err = nil
+      attempts.times do |attempt|
+        begin
+          status, headers, raw = perform_request(method, path, body, idempotency_key)
+        rescue Net::OpenTimeout, Net::ReadTimeout => e
+          last_err = Errors::TimeoutError.new("payhub: timeout: #{e.message}")
+        rescue SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, IOError => e
+          last_err = Errors::ConnectionError.new("payhub: connection: #{e.message}")
+        else
+          if (200..299).cover?(status)
+            return decode_2xx(raw)
+          end
+          err = build_api_error(status, raw, headers)
+          if retriable && (status >= 500 || status == 429) && attempt + 1 < attempts
+            wait = retry_after(headers) || backoff_seconds(attempt)
+            sleep(wait)
+            last_err = err
+            next
+          end
+          raise err
+        end
+        sleep(backoff_seconds(attempt)) if attempt + 1 < attempts
+      end
+      raise last_err if last_err
+      raise Errors::Error, "payhub: unreachable retry loop"
+    end
+
+    private
+
+    def perform_request(method, path, body, idempotency_key)
+      uri = URI.parse(@base_url + path)
+      req_class = case method
+      when :get then Net::HTTP::Get
+      when :post then Net::HTTP::Post
+      when :delete then Net::HTTP::Delete
+      else raise ArgumentError, "unsupported method: #{method}"
+      end
+      req = req_class.new(uri.request_uri)
+      req["Authorization"] = "Bearer #{@api_key}"
+      req["Accept"] = "application/json"
+      req["User-Agent"] = @user_agent
+      req["Idempotency-Key"] = idempotency_key if idempotency_key
+      if body
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+
+      http = @http_client || begin
+        h = Net::HTTP.new(uri.host, uri.port)
+        h.use_ssl = (uri.scheme == "https")
+        h.open_timeout = @timeout
+        h.read_timeout = @timeout
+        h
+      end
+      resp = http.request(req)
+      [resp.code.to_i, resp.to_hash.transform_keys(&:downcase), resp.body || ""]
+    end
+
+    def decode_2xx(raw)
+      return nil if raw.nil? || raw.empty?
+      JSON.parse(raw)
+    rescue JSON::ParserError => e
+      raise Errors::DecodeError, "payhub: decode: #{e.message}"
+    end
+
+    def build_api_error(status, raw, headers)
+      envelope = parse_envelope(raw, status)
+      Errors.from_envelope(envelope, status, retry_after: retry_after(headers))
+    end
+
+    def parse_envelope(raw, status)
+      JSON.parse(raw)
+    rescue JSON::ParserError, TypeError
+      {"error" => {"code" => "hub.unknown", "message" => "HTTP #{status}"}}
+    end
+
+    def retry_after(headers)
+      v = headers && (headers["retry-after"] || headers["Retry-After"])
+      Array(v).first&.to_i
+    end
+
+    def backoff_seconds(attempt)
+      base = 0.5 * (2**attempt)
+      base * (0.8 + rand * 0.4)
+    end
+
+    def build_user_agent(suffix)
+      base = "payhub-ruby/#{VERSION} (ruby #{RUBY_VERSION}; #{RbConfig::CONFIG["host_os"]})"
+      suffix ? "#{base} #{suffix}" : base
+    end
+
+    class Payments
+      def initialize(client)
+        @c = client
+      end
+
+      def create(request, idempotency_key: nil)
+        key = idempotency_key || SecureRandom.uuid
+        raw = @c.request(:post, "/v1/payments", body: request, idempotency_key: key)
+        Payment.from_raw(raw)
+      end
+
+      def confirm_otp(payment_id, code, idempotency_key: nil)
+        key = idempotency_key || SecureRandom.uuid
+        raw = @c.request(:post, "/v1/payments/#{payment_id}/otp",
+          body: {code: code}, idempotency_key: key)
+        Payment.from_raw(raw)
+      end
+
+      def refund(payment_id, amount_minor: nil, reason: nil, idempotency_key: nil)
+        body = {}
+        body[:amount_minor] = amount_minor unless amount_minor.nil?
+        body[:reason] = reason unless reason.nil?
+        key = idempotency_key || SecureRandom.uuid
+        raw = @c.request(:post, "/v1/payments/#{payment_id}/refund",
+          body: body, idempotency_key: key)
+        Payment.from_raw(raw)
+      end
+
+      def retrieve(payment_id)
+        Payment.from_raw(@c.request(:get, "/v1/payments/#{payment_id}"))
+      end
+    end
+
+    class HealthResource
+      def initialize(client)
+        @c = client
+      end
+
+      def check
+        Health.from_raw(@c.request(:get, "/v1/health"))
+      end
+    end
+  end
+end

data/lib/payhub/errors.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Typed exception hierarchy mirroring app/core/errors.py. Maps the server's
+# {error: {code, message, details, request_id}} envelope plus HTTP status to
+# a precise subclass so callers `rescue Payhub::Errors::AuthenticationError`
+# instead of inspecting strings.
+
+module Payhub
+  module Errors
+    class Error < StandardError; end
+
+    class APIError < Error
+      attr_reader :code, :http_status, :details, :request_id
+
+      def initialize(message, code:, http_status:, details: nil, request_id: nil)
+        msg = request_id ? "#{message} [request_id=#{request_id}]" : message
+        super(msg)
+        @code = code
+        @http_status = http_status
+        @details = details || {}
+        @request_id = request_id
+      end
+    end
+
+    class AuthenticationError < APIError; end
+    class PermissionError < APIError; end
+    class NotFoundError < APIError; end
+    class ValidationError < APIError; end
+    class IdempotencyConflictError < APIError; end
+
+    class RateLimitedError < APIError
+      attr_reader :retry_after
+
+      def initialize(message, retry_after: nil, **kwargs)
+        super(message, **kwargs)
+        @retry_after = retry_after
+      end
+    end
+
+    class GatewayError < APIError; end
+    class ServerError < APIError; end
+
+    class TransportError < Error; end
+    class TimeoutError < TransportError; end
+    class ConnectionError < TransportError; end
+    class DecodeError < TransportError; end
+
+    class << self
+      def from_envelope(envelope, http_status, retry_after: nil)
+        err = (envelope.is_a?(Hash) && envelope["error"].is_a?(Hash)) ? envelope["error"] : {}
+        code = err["code"] || "hub.unknown"
+        message = err["message"] || "HTTP #{http_status}"
+        details = err["details"] || {}
+        request_id = err["request_id"]
+        common = {code: code, http_status: http_status, details: details, request_id: request_id}
+
+        case http_status
+        when 401 then AuthenticationError.new(message, **common)
+        when 403 then PermissionError.new(message, **common)
+        when 404 then NotFoundError.new(message, **common)
+        when 409 then IdempotencyConflictError.new(message, **common)
+        when 422 then ValidationError.new(message, **common)
+        when 429 then RateLimitedError.new(message, retry_after: retry_after, **common)
+        else
+          if (500..599).cover?(http_status)
+            code.start_with?("gateway.") ? GatewayError.new(message, **common) : ServerError.new(message, **common)
+          else
+            APIError.new(message, **common)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payhub/next_action.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Discriminated NextAction returned in payment.next_action.
+#
+# Ruby has no sealed-classes; instead, decode_next_action returns a frozen
+# struct subclass keyed off the kind so callers can `case na in OtpRequired`.
+
+module Payhub
+  module NextAction
+    OtpRequired = Struct.new(:psp_ref, :masked_destination, :expires_at, keyword_init: true) do
+      def kind = :otp_required
+    end
+
+    Redirect = Struct.new(:url, :method, :fields, :expires_at, keyword_init: true) do
+      def kind = :redirect
+    end
+
+    QR = Struct.new(:reference, :qr_payload, :expires_at, keyword_init: true) do
+      def kind = :qr
+    end
+
+    Lightbox = Struct.new(:params, :script_url, keyword_init: true) do
+      def kind = :lightbox
+    end
+
+    class << self
+      def decode(raw)
+        return nil if raw.nil?
+        raise ArgumentError, "next_action must be an object or nil" unless raw.is_a?(Hash)
+
+        case raw["type"]
+        when "otp_required"
+          OtpRequired.new(
+            psp_ref: raw["psp_ref"].to_s,
+            masked_destination: raw["masked_destination"].to_s,
+            expires_at: raw["expires_at"]
+          )
+        when "redirect"
+          Redirect.new(
+            url: raw["url"].to_s,
+            method: (raw["method"] || "GET").to_s.upcase,
+            fields: (raw["fields"] || {}).each_with_object({}) { |(k, v), h| h[k.to_s] = v.to_s },
+            expires_at: raw["expires_at"]
+          )
+        when "qr"
+          QR.new(
+            reference: raw["reference"].to_s,
+            qr_payload: raw["qr_payload"].to_s,
+            expires_at: raw["expires_at"]
+          )
+        when "lightbox"
+          params = (raw["params"] || {}).each_with_object({}) { |(k, v), h| h[k.to_s] = v.to_s }
+          Lightbox.new(params: params, script_url: params["lightbox_js_url"])
+        else
+          raise ArgumentError, "unknown next_action.type: #{raw["type"].inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/payhub/types.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "next_action"
+
+module Payhub
+  Payment = Struct.new(
+    :id, :status, :psp, :psp_ref, :next_action, :amount_minor,
+    :currency, :merchant_order_ref, :hosted_checkout_url,
+    keyword_init: true
+  ) do
+    def self.from_raw(raw)
+      new(
+        id: raw["id"].to_s,
+        status: raw["status"].to_s,
+        psp: raw["psp"].to_s,
+        psp_ref: raw["psp_ref"],
+        next_action: Payhub::NextAction.decode(raw["next_action"]),
+        amount_minor: raw["amount_minor"].to_i,
+        currency: raw["currency"].to_s,
+        merchant_order_ref: raw["merchant_order_ref"].to_s,
+        hosted_checkout_url: raw["hosted_checkout_url"]
+      )
+    end
+  end
+
+  # Refund row currently mirrors Payment.
+  Refund = Payment
+
+  Health = Struct.new(:status, :psps, keyword_init: true) do
+    def self.from_raw(raw)
+      new(status: raw["status"].to_s, psps: Array(raw["psps"]))
+    end
+  end
+end

data/lib/payhub/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Payhub
+  VERSION = "1.0.1"
+end

data/lib/payhub/webhook.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+
+# Webhook signature verification.
+#
+# Algorithmic reference: app/core/signing.py. Header is
+#   Hub-Signature: t=<unix>,v1=<hmac_sha256_hex>
+# Signed bytes: "#{t}.".b + raw_body. Default tolerance ±300 s.
+#
+# Every PayHub SDK ports the same algorithm; the canonical fixtures at
+# sdks/shared/test-vectors/webhook-signing.json are the spec.
+
+module Payhub
+  class WebhookSignatureError < StandardError; end
+
+  class MalformedHeaderError < WebhookSignatureError; end
+
+  class TimestampOutOfToleranceError < WebhookSignatureError
+    attr_reader :skew_seconds
+
+    def initialize(skew_seconds)
+      super("webhook timestamp out of tolerance: #{skew_seconds}s skew")
+      @skew_seconds = skew_seconds
+    end
+  end
+
+  class InvalidSignatureError < WebhookSignatureError; end
+
+  WebhookEventPayload = Struct.new(
+    :id, :type, :payment_id, :prev_status, :new_status, :source, :payload, :created_at,
+    keyword_init: true
+  )
+
+  module WebhookEvent
+    DEFAULT_TOLERANCE_SECONDS = 300
+
+    class << self
+      # Verify a webhook delivery and return the decoded event.
+      # Raises Payhub::MalformedHeaderError, TimestampOutOfToleranceError, or InvalidSignatureError.
+      def verify(secret, body, header, tolerance_seconds: DEFAULT_TOLERANCE_SECONDS, now: nil)
+        secret_b = secret.is_a?(String) ? secret.b : secret.to_s.b
+        body_b = body.is_a?(String) ? body.b : body.to_s.b
+
+        t, v1 = parse_header(header)
+        wall_now = now || Time.now.to_i
+        skew = (wall_now - t).abs
+        raise TimestampOutOfToleranceError.new(skew) if skew > tolerance_seconds
+
+        signed = "#{t}.".b + body_b
+        expected = OpenSSL::HMAC.hexdigest("SHA256", secret_b, signed)
+        raise InvalidSignatureError, "Hub-Signature v1 does not match" unless secure_compare(expected, v1)
+
+        decode_payload(body_b)
+      end
+
+      private
+
+      def parse_header(header)
+        parts = {}
+        header.to_s.split(",").each do |seg|
+          k, _, v = seg.partition("=")
+          parts[k.strip] = v.strip unless v.empty?
+        end
+        unless parts.key?("t") && parts.key?("v1")
+          raise MalformedHeaderError, "Hub-Signature missing t or v1: #{header.inspect}"
+        end
+        begin
+          t = Integer(parts["t"], 10)
+        rescue ArgumentError, TypeError
+          raise MalformedHeaderError, "Hub-Signature t is not an integer: #{parts["t"].inspect}"
+        end
+        [t, parts["v1"]]
+      end
+
+      def secure_compare(a, b)
+        return false unless a.bytesize == b.bytesize
+        OpenSSL.fixed_length_secure_compare(a.b, b.b)
+      end
+
+      def decode_payload(body_bytes)
+        return WebhookEventPayload.new if body_bytes.empty?
+        begin
+          raw = JSON.parse(body_bytes)
+        rescue JSON::ParserError => e
+          raise InvalidSignatureError, "webhook body is not JSON: #{e.message}"
+        end
+        raise InvalidSignatureError, "webhook body is not a JSON object" unless raw.is_a?(Hash)
+
+        WebhookEventPayload.new(
+          id: raw["id"].to_s,
+          type: raw["type"].to_s,
+          payment_id: raw["payment_id"].to_s,
+          prev_status: raw["prev_status"],
+          new_status: raw["new_status"].to_s,
+          source: raw["source"].to_s,
+          payload: raw["payload"] || {},
+          created_at: raw["created_at"].to_s
+        )
+      end
+    end
+  end
+end

data/lib/payhub.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "payhub/version"
+require_relative "payhub/errors"
+require_relative "payhub/next_action"
+require_relative "payhub/types"
+require_relative "payhub/webhook"
+require_relative "payhub/client"
+
+# Top-level shortcut so `Payhub.new("phk_…")` works.
+module Payhub
+  def self.new(*args, **kwargs)
+    Client.new(*args, **kwargs)
+  end
+end

data/payhub.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "lib/payhub/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "payhub"
+  spec.version = Payhub::VERSION
+  spec.authors = ["SafwaTech"]
+  spec.email = ["sdk@payhub.ly"]
+
+  spec.summary = "Official PayHub SDK for Ruby."
+  spec.description = "Idempotent client + webhook verifier for the PayHub v1 payment hub. Targets Libyan PSPs (Sadad, Moamalat, Mobicash, T-Lync, Adfali)."
+  spec.homepage = "https://payhub.ly"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/safwatech/payhub-ruby"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/safwatech/payhub-ruby/issues"
+  spec.metadata["changelog_uri"] = "https://github.com/safwatech/payhub-ruby/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.glob("{lib,LICENSE,README.md}/**/*") + ["LICENSE", "README.md", "payhub.gemspec"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec", "~> 3.13"
+  spec.add_development_dependency "webmock", "~> 3.23"
+  spec.add_development_dependency "standard", "~> 1.40"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: payhub
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- SafwaTech
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.40'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.40'
+description: Idempotent client + webhook verifier for the PayHub v1 payment hub. Targets
+  Libyan PSPs (Sadad, Moamalat, Mobicash, T-Lync, Adfali).
+email:
+- sdk@payhub.ly
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/payhub.rb
+- lib/payhub/client.rb
+- lib/payhub/errors.rb
+- lib/payhub/next_action.rb
+- lib/payhub/types.rb
+- lib/payhub/version.rb
+- lib/payhub/webhook.rb
+- payhub.gemspec
+homepage: https://payhub.ly
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://payhub.ly
+  source_code_uri: https://github.com/safwatech/payhub-ruby
+  bug_tracker_uri: https://github.com/safwatech/payhub-ruby/issues
+  changelog_uri: https://github.com/safwatech/payhub-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Official PayHub SDK for Ruby.
+test_files: []