wirepayment 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b5791532cdc9970945e66a9d1743b4074db2ca11fa118b6d2a2b073618940df9
+  data.tar.gz: 4e14b8cf1875b6f3f091743a4da11260815751981840f341e073ff5d622c3036
+SHA512:
+  metadata.gz: 2688c7e8b3ae09fe8149a73c13314bb9ade7ae5b476512d737182b66dac5d9853e5f83ddba6dbbb14ee3b20fe8fc5a715d5c1a77cdcd1c44991abab94fe05909
+  data.tar.gz: a156cbe508a41e8a0e89811d1cc86a88519099d20e5d0daacfdfa7f13a53e3a1dbfe727b75c1f8b88e72908d5f0e418d6edb923ece717883dc310441825804fa

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-06-07
+
+### Added
+- Initial release of the `wirepayment` gem (`Wire` namespace).
+- `Wire::Client` with Bearer auth, JSON encoding, configurable `base_url`,
+  `timeout`, `max_retries`, and `backoff`.
+- Automatic `Idempotency-Key` on POST requests, reused across retries.
+- Exponential backoff with jitter on 429, 5xx, and network errors; honors
+  `Retry-After`.
+- Resources: payment intents (create, retrieve, confirm, cancel, list),
+  charges (retrieve, list), events (retrieve, list), webhook endpoints
+  (create, retrieve, update, delete, list).
+- Cursor auto-pagination via lazy `Enumerator` following `has_more`.
+- Typed `Wire::WireError` decoded from the API error envelope; distinct
+  `Wire::ConnectionError` / `Wire::TimeoutError` for transport failures.
+- `Wire::Webhook.verify` with HMAC-SHA256 signature verification, constant-time
+  comparison, timestamp tolerance, and fail-closed behavior.
+
+[1.0.0]: https://github.com/buildry-wire/wire-ruby/releases/tag/v1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Buildry
+
+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,114 @@
+# wirepayment
+
+Official Ruby SDK for the [Wire](https://wire.mn) payment API — a unified
+gateway over Mongolian payment operators. Server-side, Ruby 3.0+, built on the
+standard library with no third-party runtime dependencies.
+
+Full documentation: [docs.wire.mn](https://docs.wire.mn)
+
+## Install
+
+```ruby
+# Gemfile
+gem "wirepayment"
+```
+
+```bash
+bundle install
+# or
+gem install wirepayment
+```
+
+```ruby
+require "wirepayment"
+```
+
+## Quickstart
+
+```ruby
+client = Wire::Client.new("sk_live_...")
+
+# Amounts are in minor units (e.g. 50000 = 500.00 MNT).
+pi = client.payment_intents.create(
+  amount: 50_000,
+  currency: "MNT",
+  allowed_operators: ["sandbox"] # the operator ids enabled on your account
+)
+puts pi["id"], pi["status"]
+
+# Confirm it.
+confirmed = client.payment_intents.confirm(pi["id"], return_url: "https://example.com/return")
+puts confirmed["status"]
+```
+
+## Configuration
+
+```ruby
+client = Wire::Client.new(
+  "sk_live_...",
+  base_url: "https://api.wire.mn", # default
+  timeout: 30,                     # seconds, default
+  max_retries: 2,                  # default; retries 429/5xx/network with backoff
+  backoff: 0.5                     # base seconds for exponential backoff w/ jitter
+)
+```
+
+Every POST automatically sends an `Idempotency-Key` (generated if you don't
+supply one), and the same key is reused across retries. Pass your own with
+`idempotency_key:`.
+
+## Auto-pagination
+
+`list` returns a lazy `Enumerator` that follows `has_more` across pages:
+
+```ruby
+client.charges.list(limit: 50).each do |charge|
+  puts charge["id"]
+end
+
+# Or collect everything:
+events = client.events.list.to_a
+```
+
+## Webhook verification
+
+Verify against the **raw** request body, before any JSON parsing:
+
+```ruby
+require "wirepayment"
+
+# In a Rack/Rails controller:
+payload = request.body.read
+sig_header = request.headers[Wire::Webhook::SIGNATURE_HEADER] # "WirePayment-Signature"
+
+begin
+  event = Wire::Webhook.verify(payload, sig_header, ENV["WIRE_WEBHOOK_SECRET"])
+  puts event["type"]
+rescue Wire::SignatureVerificationError
+  head :bad_request
+end
+```
+
+## Error handling
+
+```ruby
+begin
+  client.payment_intents.retrieve("pi_missing")
+rescue Wire::WireError => e
+  e.type                  # e.g. "invalid_request_error"
+  e.code                  # e.g. "resource_missing"
+  e.param
+  e.request_id            # always preserved when present
+  e.doc_url
+  e.operator_decline_code
+  e.status_code           # HTTP status
+rescue Wire::ConnectionError => e
+  # network failure or timeout (Wire::TimeoutError is a subclass)
+end
+```
+
+The SDK never logs your API key and never includes it in error messages.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/lib/wire/client.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "securerandom"
+require "uri"
+
+require_relative "errors"
+require_relative "resources/payment_intents"
+require_relative "resources/charges"
+require_relative "resources/events"
+require_relative "resources/webhook_endpoints"
+
+module Wire
+  DEFAULT_BASE_URL = "https://api.wire.mn"
+
+  # Client is the Wire API client. Construct it with an API key (sk_live_...).
+  #
+  #   client = Wire::Client.new("sk_live_...")
+  #   pi = client.payment_intents.create(amount: 50_000, currency: "MNT")
+  class Client
+    attr_reader :payment_intents, :charges, :events, :webhook_endpoints
+
+    # @param api_key [String] secret API key (sk_live_...).
+    # @param base_url [String] API base URL.
+    # @param timeout [Numeric] per-request timeout in seconds.
+    # @param max_retries [Integer] retry attempts for 429/5xx/network errors.
+    # @param backoff [Numeric] base backoff in seconds (exponential w/ jitter).
+    # @param http_adapter an optional object responding to
+    #   #call(method, uri, headers, body, timeout) -> Wire::Response. Used to
+    #   inject a stub transport in tests; defaults to Net::HTTP.
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, timeout: 30,
+                   max_retries: 2, backoff: 0.5, http_adapter: nil)
+      raise ArgumentError, "api_key is required" if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = base_url.sub(%r{/+\z}, "")
+      @timeout = timeout
+      @max_retries = max_retries
+      @backoff = backoff
+      @http_adapter = http_adapter || NetHTTPAdapter.new
+
+      @payment_intents = Resources::PaymentIntents.new(self)
+      @charges = Resources::Charges.new(self)
+      @events = Resources::Events.new(self)
+      @webhook_endpoints = Resources::WebhookEndpoints.new(self)
+    end
+
+    # request performs an HTTP request with auth, idempotency, retries, and
+    # error decoding, returning the parsed JSON body as a Hash.
+    #
+    # @param method [String] HTTP method ("GET", "POST", "DELETE").
+    # @param path [String] request path (e.g. "/v1/payment_intents").
+    # @param body [Hash, nil] request body, JSON-encoded when present.
+    # @param query [Hash, nil] query parameters.
+    # @param idempotency_key [String, nil] reused across retries; a random key
+    #   is generated for POST when absent.
+    def request(method, path, body: nil, query: nil, idempotency_key: nil)
+      uri = build_uri(path, query)
+
+      headers = {
+        "Authorization" => "Bearer #{@api_key}",
+        "Accept" => "application/json"
+      }
+      body_str = nil
+      unless body.nil?
+        body_str = JSON.generate(body)
+        headers["Content-Type"] = "application/json"
+      end
+      if method == "POST"
+        headers["Idempotency-Key"] = idempotency_key || self.class.new_idempotency_key
+      end
+
+      attempt = 0
+      loop do
+        begin
+          resp = @http_adapter.call(method, uri, headers, body_str, @timeout)
+        rescue TimeoutError, ConnectionError => e
+          if attempt < @max_retries
+            sleep_for(backoff_delay(attempt))
+            attempt += 1
+            next
+          end
+          raise e
+        end
+
+        if (resp.status == 429 || resp.status >= 500) && attempt < @max_retries
+          delay = retry_after(resp.headers) || backoff_delay(attempt)
+          sleep_for(delay)
+          attempt += 1
+          next
+        end
+
+        return handle_response(resp)
+      end
+    end
+
+    def self.new_idempotency_key
+      "idk_#{SecureRandom.hex(16)}"
+    end
+
+    private
+
+    def build_uri(path, query)
+      uri = URI.parse(@base_url + path)
+      if query && !query.empty?
+        pairs = query.reject { |_k, v| v.nil? || v == "" || v == 0 }
+        uri.query = URI.encode_www_form(pairs) unless pairs.empty?
+      end
+      uri
+    end
+
+    def handle_response(resp)
+      body = resp.body.to_s
+      if resp.status >= 200 && resp.status < 300
+        return body.empty? ? {} : JSON.parse(body)
+      end
+      raise Wire.parse_error(resp.status, body)
+    end
+
+    # Exponential backoff with full jitter.
+    def backoff_delay(attempt)
+      base = @backoff * (2**attempt)
+      rand * base
+    end
+
+    def retry_after(headers)
+      raw = headers["retry-after"] || headers["Retry-After"]
+      return nil if raw.nil? || raw.to_s.empty?
+
+      n = Integer(raw, exception: false)
+      n&.positive? ? n.to_f : nil
+    end
+
+    def sleep_for(seconds)
+      sleep(seconds) if seconds&.positive?
+    end
+  end
+
+  # Response is the transport-agnostic result an http_adapter must return.
+  Response = Struct.new(:status, :headers, :body, keyword_init: true)
+
+  # NetHTTPAdapter is the default transport, built on stdlib Net::HTTP.
+  class NetHTTPAdapter
+    def call(method, uri, headers, body, timeout)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http.write_timeout = timeout if http.respond_to?(:write_timeout=)
+
+      req = build_request(method, uri, headers, body)
+
+      begin
+        res = http.request(req)
+      rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout => e
+        raise Wire::TimeoutError, "request timed out: #{e.message}"
+      rescue SocketError, SystemCallError, IOError, OpenSSL::SSL::SSLError => e
+        raise Wire::ConnectionError, "request failed: #{e.message}"
+      end
+
+      Wire::Response.new(
+        status: res.code.to_i,
+        headers: normalize_headers(res),
+        body: res.body
+      )
+    end
+
+    private
+
+    def build_request(method, uri, headers, body)
+      klass = case method
+              when "GET" then Net::HTTP::Get
+              when "POST" then Net::HTTP::Post
+              when "DELETE" then Net::HTTP::Delete
+              when "PUT" then Net::HTTP::Put
+              else raise ArgumentError, "unsupported method: #{method}"
+              end
+      req = klass.new(uri.request_uri)
+      headers.each { |k, v| req[k] = v }
+      req.body = body if body
+      req
+    end
+
+    def normalize_headers(res)
+      out = {}
+      res.each_header { |k, v| out[k.downcase] = v }
+      out
+    end
+  end
+end

data/lib/wire/errors.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Wire
+  # Base class for every error raised by this library.
+  class Error < StandardError; end
+
+  # WireError is a typed error decoded from the API error envelope
+  # ({ "error": { ... } }). It is raised for any non-2xx API response.
+  class WireError < Error
+    attr_reader :type, :code, :param, :request_id, :doc_url,
+                :operator_decline_code, :status_code
+
+    def initialize(message, type: "api_error", code: nil, param: nil,
+                   request_id: nil, doc_url: nil, operator_decline_code: nil,
+                   status_code: nil)
+      super(message)
+      @type = type
+      @code = code
+      @param = param
+      @request_id = request_id
+      @doc_url = doc_url
+      @operator_decline_code = operator_decline_code
+      @status_code = status_code
+    end
+
+    def to_s
+      "#{super} (type=#{type}, code=#{code}, status=#{status_code}, " \
+        "request_id=#{request_id})"
+    end
+  end
+
+  # Raised for connection failures and request timeouts. Distinct from
+  # WireError so callers can treat transport problems separately.
+  class ConnectionError < Error; end
+
+  # Raised when a request exceeds the configured timeout.
+  class TimeoutError < ConnectionError; end
+
+  # Decode the Wire error envelope; fall back to a generic error.
+  #
+  # The api_key is never read from or echoed into the error.
+  def self.parse_error(status, body)
+    begin
+      env = JSON.parse(body)
+      err = env.is_a?(Hash) ? env["error"] : nil
+      if err.is_a?(Hash)
+        return WireError.new(
+          err["message"] || "request failed",
+          type: err["type"] || "api_error",
+          code: err["code"],
+          param: err["param"],
+          request_id: err["request_id"],
+          doc_url: err["doc_url"],
+          operator_decline_code: err["operator_decline_code"],
+          status_code: status
+        )
+      end
+    rescue JSON::ParserError
+      # fall through to generic error
+    end
+
+    WireError.new(
+      "unexpected response (status #{status})",
+      type: "api_error",
+      status_code: status
+    )
+  end
+end

data/lib/wire/resources/base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Wire
+  module Resources
+    # Base provides shared helpers for resource classes, notably the
+    # cursor auto-pagination enumerator.
+    class Base
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      # paginate returns an Enumerator that yields every item across pages,
+      # following has_more via starting_after. It is lazy: pages are fetched
+      # only as the caller iterates.
+      #
+      #   client.charges.list(limit: 50).each { |ch| ... }
+      #   client.charges.list.to_a
+      def paginate(path, params)
+        params ||= {}
+        limit = params[:limit] || params["limit"]
+        after = params[:starting_after] || params["starting_after"] || ""
+
+        Enumerator.new do |yielder|
+          loop do
+            page = @client.request(
+              "GET", path,
+              query: { "limit" => limit, "starting_after" => (after unless after.to_s.empty?) }
+            )
+            data = page["data"] || []
+            data.each do |item|
+              after = item["id"]
+              yielder << item
+            end
+            break if !page["has_more"] || data.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wire/resources/charges.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wire
+  module Resources
+    # Charges: retrieve, list.
+    class Charges < Base
+      def retrieve(id)
+        @client.request("GET", "/v1/charges/#{URI.encode_www_form_component(id.to_s)}")
+      end
+
+      # Returns an Enumerator that auto-paginates across all pages.
+      def list(params = {})
+        paginate("/v1/charges", params)
+      end
+    end
+  end
+end

data/lib/wire/resources/events.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wire
+  module Resources
+    # Events: retrieve, list.
+    class Events < Base
+      def retrieve(id)
+        @client.request("GET", "/v1/events/#{URI.encode_www_form_component(id.to_s)}")
+      end
+
+      # Returns an Enumerator that auto-paginates across all pages.
+      def list(params = {})
+        paginate("/v1/events", params)
+      end
+    end
+  end
+end

data/lib/wire/resources/payment_intents.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wire
+  module Resources
+    # PaymentIntents: create, retrieve, confirm, cancel, list.
+    class PaymentIntents < Base
+      # @param params [Hash] amount:, currency:, automatic_operator:,
+      #   allowed_operators:, metadata:. Pass idempotency_key: to override.
+      def create(params = {})
+        params = params.dup
+        key = params.delete(:idempotency_key) || params.delete("idempotency_key")
+        @client.request("POST", "/v1/payment_intents", body: params, idempotency_key: key)
+      end
+
+      def retrieve(id)
+        @client.request("GET", "/v1/payment_intents/#{escape(id)}")
+      end
+
+      def confirm(id, params = {})
+        params = params.dup
+        key = params.delete(:idempotency_key) || params.delete("idempotency_key")
+        @client.request(
+          "POST", "/v1/payment_intents/#{escape(id)}/confirm",
+          body: params, idempotency_key: key
+        )
+      end
+
+      def cancel(id, idempotency_key: nil)
+        @client.request(
+          "POST", "/v1/payment_intents/#{escape(id)}/cancel",
+          body: {}, idempotency_key: idempotency_key
+        )
+      end
+
+      # Returns an Enumerator that auto-paginates across all pages.
+      def list(params = {})
+        paginate("/v1/payment_intents", params)
+      end
+
+      private
+
+      def escape(id)
+        URI.encode_www_form_component(id.to_s)
+      end
+    end
+  end
+end

data/lib/wire/resources/webhook_endpoints.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Wire
+  module Resources
+    # WebhookEndpoints: create, retrieve, update, delete, list.
+    class WebhookEndpoints < Base
+      # @param params [Hash] url:, enabled_events:. Pass idempotency_key: to override.
+      def create(params = {})
+        params = params.dup
+        key = params.delete(:idempotency_key) || params.delete("idempotency_key")
+        @client.request("POST", "/v1/webhook_endpoints", body: params, idempotency_key: key)
+      end
+
+      def retrieve(id)
+        @client.request("GET", "/v1/webhook_endpoints/#{escape(id)}")
+      end
+
+      # @param params [Hash] url:, enabled_events:, status:.
+      def update(id, params = {})
+        params = params.dup
+        key = params.delete(:idempotency_key) || params.delete("idempotency_key")
+        @client.request(
+          "POST", "/v1/webhook_endpoints/#{escape(id)}",
+          body: params, idempotency_key: key
+        )
+      end
+
+      def delete(id)
+        @client.request("DELETE", "/v1/webhook_endpoints/#{escape(id)}")
+      end
+
+      # Returns an Enumerator that auto-paginates across all pages.
+      def list(params = {})
+        paginate("/v1/webhook_endpoints", params)
+      end
+
+      private
+
+      def escape(id)
+        URI.encode_www_form_component(id.to_s)
+      end
+    end
+  end
+end

data/lib/wire/version.rb

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

data/lib/wire/webhook.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+
+require_relative "errors"
+
+module Wire
+  # Raised when a webhook signature does not verify (fail closed).
+  class SignatureVerificationError < Error; end
+
+  # Webhook verifies inbound webhook signatures.
+  #
+  # Header format: "WirePayment-Signature: t=<unix>,v1=<hex>" where
+  #   hex = HMAC-SHA256(secret, "<t>.<rawBody>")
+  #
+  # Verification runs on the RAW request body, before any JSON parsing.
+  module Webhook
+    SIGNATURE_HEADER = "WirePayment-Signature"
+    DEFAULT_TOLERANCE_SECONDS = 300
+
+    module_function
+
+    # Verify a webhook signature and return the parsed event (Hash).
+    #
+    # @param payload [String] raw, unparsed request body.
+    # @param header [String] value of the WirePayment-Signature header.
+    # @param secret [String] endpoint signing secret (whsec_...).
+    # @param tolerance [Integer] max allowed clock skew in seconds.
+    # @raise [SignatureVerificationError] on any parse failure, timestamp
+    #   outside tolerance, or signature mismatch.
+    def verify(payload, header, secret, tolerance: DEFAULT_TOLERANCE_SECONDS)
+      verify_at(payload, header, secret, tolerance: tolerance, now: Time.now.to_i)
+    end
+
+    # verify_at is the testable core taking an explicit `now` (unix seconds).
+    def verify_at(payload, header, secret, tolerance: DEFAULT_TOLERANCE_SECONDS, now:)
+      t, v1 = parse_header(header)
+      raise SignatureVerificationError, "malformed signature header" if t.nil? || v1.nil? || v1.empty?
+
+      if (now - t).abs > tolerance
+        raise SignatureVerificationError, "timestamp outside tolerance"
+      end
+
+      body = payload.to_s
+      expected = OpenSSL::HMAC.hexdigest("SHA256", secret, "#{t}.#{body}")
+
+      unless secure_compare(expected, v1)
+        raise SignatureVerificationError, "signature mismatch"
+      end
+
+      JSON.parse(body)
+    end
+
+    # parse_header extracts t (Integer) and v1 (hex String) from the header.
+    # Returns [nil, nil] when t is missing or not an integer.
+    def parse_header(header)
+      t = nil
+      v1 = nil
+      header.to_s.split(",").each do |part|
+        k, v = part.strip.split("=", 2)
+        case k
+        when "t"
+          parsed = Integer(v, exception: false)
+          return [nil, nil] if parsed.nil?
+
+          t = parsed
+        when "v1"
+          v1 = v
+        end
+      end
+      [t, v1]
+    end
+
+    # Constant-time comparison. Prefers OpenSSL's fixed-length compare,
+    # falling back to a Rack-style XOR comparison on older rubies.
+    def secure_compare(a, b)
+      a = a.to_s
+      b = b.to_s
+      if OpenSSL.respond_to?(:fixed_length_secure_compare)
+        return false unless a.bytesize == b.bytesize
+
+        OpenSSL.fixed_length_secure_compare(a, b)
+      else
+        return false unless a.bytesize == b.bytesize
+
+        l = a.unpack("C*")
+        res = 0
+        b.each_byte { |byte| res |= byte ^ l.shift }
+        res.zero?
+      end
+    end
+  end
+end

data/lib/wirepayment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "wire/version"
+require_relative "wire/errors"
+require_relative "wire/webhook"
+require_relative "wire/client"
+
+# Wire is the top-level namespace for the Wire payment API SDK.
+#
+#   client = Wire::Client.new("sk_live_...")
+#   pi = client.payment_intents.create(amount: 50_000, currency: "MNT")
+module Wire
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: wirepayment
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Buildry
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-07 00:00:00.000000000 Z
+dependencies: []
+description: 'Server-side Ruby client for the Wire unified payment gateway: payment
+  intents, charges, events, and webhook endpoints across Mongolian payment operators,
+  with automatic retries, idempotency, cursor auto-pagination, and webhook signature
+  verification.'
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/wire/client.rb
+- lib/wire/errors.rb
+- lib/wire/resources/base.rb
+- lib/wire/resources/charges.rb
+- lib/wire/resources/events.rb
+- lib/wire/resources/payment_intents.rb
+- lib/wire/resources/webhook_endpoints.rb
+- lib/wire/version.rb
+- lib/wire/webhook.rb
+- lib/wirepayment.rb
+homepage: https://github.com/buildry-wire/wire-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/buildry-wire/wire-ruby
+  source_code_uri: https://github.com/buildry-wire/wire-ruby
+  documentation_uri: https://docs.wire.mn
+  changelog_uri: https://github.com/buildry-wire/wire-ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/buildry-wire/wire-ruby/issues
+  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.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 Ruby SDK for the Wire payment API.
+test_files: []