sunny-payments 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 487454dfe36081782721d77218b1a9e9e1538cbbcef624b57d01a2ea68d70c7e
+  data.tar.gz: ca5c9b4f2292e796b7e14a11e381526c351d05c8db5fda9cf06fc64ac6976db3
+SHA512:
+  metadata.gz: 72ca1ceda8b61446b111c8fc51e8a1f62d176fbc311d290c972525d13dc43389c771acccf53f007c2010934b9ed33793caac3b73a52687983f70fa517f6757a4
+  data.tar.gz: f8309afac75958f824151c70a250d5735f387c06a5f8ac219b27de559b84e23f1b8a9cfe99e67f066d14e61eda630bfaa5a4307e11ff8d826081c7b7a406e2bf

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sunny Pay Limited
+
+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,165 @@
+<p align="center">
+  <img src="assets/sunny-logo.svg" alt="Sunny Payments" width="60" height="60">
+  <img src="assets/ruby.svg" alt="Ruby" width="60" height="60">
+</p>
+
+<h1 align="center">Sunny Payments Ruby SDK</h1>
+
+<p align="center">
+  The official Ruby SDK for <a href="https://sunnypay.co.ke">Sunny Payments</a> - Payment processing made simple.
+</p>
+
+<p align="center">
+  <a href="https://rubygems.org/gems/sunny-payments"><img src="https://img.shields.io/gem/v/sunny-payments.svg" alt="Gem Version"></a>
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
+</p>
+
+## Installation
+
+```bash
+gem install sunny-payments
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'sunny-payments', '~> 1.0'
+```
+
+## Quick Start
+
+```ruby
+require 'sunny'
+
+# Initialize the client
+sunny = Sunny::Client.new('sk_live_your_api_key')
+
+# Create a payment (currency is REQUIRED)
+payment = sunny.payments.create(
+  amount: 1000,
+  currency: 'KES',  # Required - no default!
+  source: 'mpesa',
+  description: 'Order #12345'
+)
+
+puts payment['id']  # pay_xxxxx
+```
+
+## Features
+
+- ✅ **Payments** - Create, capture, refund payments
+- ✅ **Mobile Money** - M-Pesa STK Push, B2C, MTN MoMo, Airtel Money
+- ✅ **Invoices** - Create and send invoices
+- ✅ **Bills** - Airtime, data, electricity payments
+- ✅ **QR Codes** - Static and dynamic QR payments
+- ✅ **Crypto** - Accept BTC, ETH, USDT, USDC
+- ✅ **Webhooks** - Register endpoints & verify signatures
+- ✅ **BNPL** - Buy Now Pay Later
+
+## Usage Examples
+
+### M-Pesa STK Push
+
+```ruby
+result = sunny.mobile_money.mpesa_stk_push(
+  phone_number: '254712345678',
+  amount: 1000,
+  currency: 'KES',  # Required
+  account_reference: 'ORDER-001'
+)
+
+# Check status
+status = sunny.mobile_money.mpesa_status(result['checkout_request_id'])
+```
+
+### Bills
+
+```ruby
+# Purchase airtime
+sunny.bills.purchase_airtime(
+  phone_number: '+254712345678',
+  amount: 100,
+  network: 'safaricom'
+)
+
+# Buy electricity tokens
+electricity = sunny.bills.purchase_electricity(
+  meter_number: '12345678',
+  amount: 500,
+  phone_number: '+254712345678'
+)
+puts electricity['token']  # KPLC token
+```
+
+### Crypto Payments
+
+```ruby
+address = sunny.crypto.create_address(
+  cryptocurrency: 'USDT',
+  amount: 10000,
+  currency: 'KES'  # Required
+)
+```
+
+### Webhooks
+
+```ruby
+# Register webhook
+webhook = sunny.webhooks.create(
+  url: 'https://example.com/webhooks/sunny',
+  events: ['payment.succeeded', 'payment.failed']
+)
+
+# In your Sinatra/Rails controller:
+post '/webhooks/sunny' do
+  payload = request.body.read
+  signature = request.env['HTTP_X_SUNNY_SIGNATURE']
+  
+  unless Sunny::Resources::Webhooks.verify_signature(payload, signature, WEBHOOK_SECRET)
+    halt 400, 'Invalid signature'
+  end
+  
+  event = JSON.parse(payload)
+  
+  case event['type']
+  when 'payment.succeeded'
+    # Handle successful payment
+  end
+  
+  status 200
+  'OK'
+end
+```
+
+## Error Handling
+
+```ruby
+begin
+  payment = sunny.payments.create(amount: 1000, currency: 'KES', source: 'mpesa')
+rescue Sunny::AuthenticationError
+  puts "Invalid API key"
+rescue Sunny::ValidationError => e
+  puts "Validation error: #{e.message}, field: #{e.field}"
+rescue Sunny::RateLimitError => e
+  puts "Rate limited. Retry after #{e.retry_after} seconds"
+rescue Sunny::APIError => e
+  puts "API error: #{e.message}"
+end
+```
+
+## Configuration
+
+```ruby
+# Via environment variable
+ENV['SUNNY_API_KEY'] = 'sk_live_xxx'
+
+# Or configure directly
+sunny = Sunny::Client.new('sk_live_xxx', {
+  base_url: 'https://api.sunnypay.co.ke/v1',
+  timeout: 30
+})
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

data/lib/sunny/client.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Sunny
+  # Main client for interacting with Sunny Payments API
+  class Client
+    attr_reader :payments, :customers, :mobile_money, :invoices, :bills,
+                :qr_codes, :crypto, :webhooks, :refunds, :virtual_accounts, :bnpl
+
+    # Initialize a new Sunny client
+    #
+    # @param api_key [String] Your Sunny API key (starts with sk_live_ or sk_test_)
+    # @param options [Hash] Optional configuration
+    # @option options [String] :base_url Custom API base URL
+    # @option options [Integer] :timeout Request timeout in seconds (default: 30)
+    def initialize(api_key, options = {})
+      raise AuthenticationError, "API key is required" if api_key.nil? || api_key.empty?
+      raise AuthenticationError, "Invalid API key format" unless api_key.start_with?("sk_")
+
+      @api_key = api_key
+      @base_url = options[:base_url] || Sunny.api_base
+      @timeout = options[:timeout] || 30
+
+      @connection = build_connection
+
+      # Initialize resources
+      @payments = Resources::Payments.new(self)
+      @customers = Resources::Customers.new(self)
+      @mobile_money = Resources::MobileMoney.new(self)
+      @invoices = Resources::Invoices.new(self)
+      @bills = Resources::Bills.new(self)
+      @qr_codes = Resources::QRCodes.new(self)
+      @crypto = Resources::Crypto.new(self)
+      @webhooks = Resources::Webhooks.new(self)
+      @refunds = Resources::Refunds.new(self)
+      @virtual_accounts = Resources::VirtualAccounts.new(self)
+      @bnpl = Resources::BNPL.new(self)
+    end
+
+    # Make a GET request
+    def get(path, params = {})
+      request(:get, path, params)
+    end
+
+    # Make a POST request
+    def post(path, body = {})
+      request(:post, path, body)
+    end
+
+    # Make a PUT request
+    def put(path, body = {})
+      request(:put, path, body)
+    end
+
+    # Make a DELETE request
+    def delete(path)
+      request(:delete, path)
+    end
+
+    private
+
+    def build_connection
+      Faraday.new(url: @base_url) do |conn|
+        conn.request :json
+        conn.response :json, content_type: /\bjson$/
+        conn.headers["Authorization"] = "Bearer #{@api_key}"
+        conn.headers["Content-Type"] = "application/json"
+        conn.headers["User-Agent"] = "sunny-ruby/#{VERSION}"
+        conn.options.timeout = @timeout
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def request(method, path, data = nil)
+      response = @connection.send(method, path, data)
+      handle_response(response)
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+      raise NetworkError, e.message
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        response.body
+      when 401
+        raise AuthenticationError, error_message(response)
+      when 400
+        raise ValidationError.new(error_message(response), field: response.body&.dig("field"))
+      when 429
+        retry_after = response.headers["Retry-After"]&.to_i || 60
+        raise RateLimitError, retry_after
+      else
+        raise APIError.new(error_message(response), status: response.status, code: response.body&.dig("code"))
+      end
+    end
+
+    def error_message(response)
+      response.body&.dig("message") || response.body&.dig("error") || "An error occurred"
+    end
+  end
+end

data/lib/sunny/errors.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Sunny
+  # Base error class for all Sunny errors
+  class SunnyError < StandardError
+    attr_reader :code, :status
+
+    def initialize(message = nil, code: nil, status: nil)
+      @code = code
+      @status = status
+      super(message)
+    end
+  end
+
+  # Raised when API key is invalid or missing
+  class AuthenticationError < SunnyError
+    def initialize(message = "Invalid API key")
+      super(message, status: 401)
+    end
+  end
+
+  # Raised when request parameters are invalid
+  class ValidationError < SunnyError
+    attr_reader :field
+
+    def initialize(message, field: nil)
+      @field = field
+      super(message, status: 400)
+    end
+  end
+
+  # Raised when rate limit is exceeded
+  class RateLimitError < SunnyError
+    attr_reader :retry_after
+
+    def initialize(retry_after = 60)
+      @retry_after = retry_after
+      super("Rate limit exceeded. Retry after #{retry_after} seconds", status: 429)
+    end
+  end
+
+  # Raised for general API errors
+  class APIError < SunnyError
+    def initialize(message, status: nil, code: nil)
+      super(message, status: status, code: code)
+    end
+  end
+
+  # Raised for network/connection errors
+  class NetworkError < SunnyError
+    def initialize(message = "Unable to connect to Sunny API")
+      super(message)
+    end
+  end
+end

data/lib/sunny/resources/bills.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # Bills resource for airtime, data, electricity
+    class Bills
+      def initialize(client)
+        @client = client
+      end
+
+      # Purchase airtime
+      #
+      # @param phone_number [String] Phone number to top up
+      # @param amount [Integer] Amount to purchase
+      # @param network [String] Network provider (safaricom, airtel, telkom)
+      def purchase_airtime(phone_number:, amount:, network:)
+        @client.post("/bills/airtime", {
+          phone_number: phone_number,
+          amount: amount,
+          network: network
+        })
+      end
+
+      # Get available data bundles
+      def get_data_bundles(network)
+        @client.get("/bills/data/bundles", { network: network })
+      end
+
+      # Purchase data bundle
+      def purchase_data(phone_number:, bundle_id:, network:)
+        @client.post("/bills/data", {
+          phone_number: phone_number,
+          bundle_id: bundle_id,
+          network: network
+        })
+      end
+
+      # Purchase electricity tokens (KPLC)
+      def purchase_electricity(meter_number:, amount:, phone_number:)
+        @client.post("/bills/electricity", {
+          meter_number: meter_number,
+          amount: amount,
+          phone_number: phone_number
+        })
+      end
+
+      # Validate electricity meter
+      def validate_meter(meter_number)
+        @client.get("/bills/electricity/validate", { meter_number: meter_number })
+      end
+
+      # Pay TV subscription
+      def pay_tv(provider:, account_number:, amount:, phone_number:)
+        @client.post("/bills/tv", {
+          provider: provider,
+          account_number: account_number,
+          amount: amount,
+          phone_number: phone_number
+        })
+      end
+    end
+  end
+end

data/lib/sunny/resources/bnpl.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # BNPL (Buy Now Pay Later) resource
+    class BNPL
+      def initialize(client)
+        @client = client
+      end
+
+      # Check customer eligibility
+      #
+      # @param customer_id [String] Customer ID
+      # @param amount [Integer] Amount to check
+      # @param currency [String] Currency code - REQUIRED
+      def check_eligibility(customer_id:, amount:, currency:)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/bnpl/eligibility", {
+          customer_id: customer_id,
+          amount: amount,
+          currency: currency
+        })
+      end
+
+      # Create a BNPL payment plan
+      def create_plan(customer_id:, amount:, currency:, installments:, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/bnpl/plans", {
+          customer_id: customer_id,
+          amount: amount,
+          currency: currency,
+          installments: installments,
+          **options
+        })
+      end
+
+      # Get a payment plan
+      def retrieve_plan(plan_id)
+        @client.get("/bnpl/plans/#{plan_id}")
+      end
+
+      # List payment plans
+      def list_plans(**params)
+        @client.get("/bnpl/plans", params)
+      end
+    end
+  end
+end

data/lib/sunny/resources/crypto.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # Crypto resource for crypto payments
+    class Crypto
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a crypto payment address
+      #
+      # @param cryptocurrency [String] Crypto type (BTC, ETH, USDT, USDC)
+      # @param amount [Integer] Expected amount in fiat
+      # @param currency [String] Fiat currency code - REQUIRED
+      # @param options [Hash] Additional options
+      def create_address(cryptocurrency:, amount:, currency:, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/crypto/addresses", {
+          cryptocurrency: cryptocurrency,
+          amount: amount,
+          currency: currency,
+          **options
+        })
+      end
+
+      # Get crypto payment status
+      def get_payment(payment_id)
+        @client.get("/crypto/payments/#{payment_id}")
+      end
+
+      # List crypto payments
+      def list_payments(**params)
+        @client.get("/crypto/payments", params)
+      end
+
+      # Get exchange rates
+      def get_rates(cryptocurrency:, currency:)
+        @client.get("/crypto/rates", {
+          cryptocurrency: cryptocurrency,
+          currency: currency
+        })
+      end
+    end
+  end
+end

data/lib/sunny/resources/customers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # Customers resource
+    class Customers
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a new customer
+      def create(email:, **options)
+        @client.post("/customers", { email: email, **options })
+      end
+
+      # Retrieve a customer
+      def retrieve(customer_id)
+        @client.get("/customers/#{customer_id}")
+      end
+
+      # Update a customer
+      def update(customer_id, **attributes)
+        @client.put("/customers/#{customer_id}", attributes)
+      end
+
+      # List customers
+      def list(**params)
+        @client.get("/customers", params)
+      end
+
+      # Delete a customer
+      def delete(customer_id)
+        @client.delete("/customers/#{customer_id}")
+      end
+    end
+  end
+end

data/lib/sunny/resources/invoices.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # Invoices resource
+    class Invoices
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a new invoice
+      #
+      # @param customer_email [String] Customer email
+      # @param amount [Integer] Invoice amount
+      # @param currency [String] Currency code - REQUIRED
+      # @param options [Hash] Additional options
+      def create(customer_email:, amount:, currency:, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/invoices", {
+          customer_email: customer_email,
+          amount: amount,
+          currency: currency,
+          **options
+        })
+      end
+
+      # Retrieve an invoice
+      def retrieve(invoice_id)
+        @client.get("/invoices/#{invoice_id}")
+      end
+
+      # List invoices
+      def list(**params)
+        @client.get("/invoices", params)
+      end
+
+      # Send an invoice
+      def send_invoice(invoice_id)
+        @client.post("/invoices/#{invoice_id}/send", {})
+      end
+
+      # Mark invoice as paid
+      def mark_paid(invoice_id)
+        @client.post("/invoices/#{invoice_id}/mark-paid", {})
+      end
+
+      # Void an invoice
+      def void(invoice_id)
+        @client.post("/invoices/#{invoice_id}/void", {})
+      end
+    end
+  end
+end

data/lib/sunny/resources/mobile_money.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # Mobile Money resource for M-Pesa, MTN MoMo, Airtel Money
+    class MobileMoney
+      def initialize(client)
+        @client = client
+      end
+
+      # Initiate M-Pesa STK Push
+      #
+      # @param phone_number [String] Customer phone number (254...)
+      # @param amount [Integer] Amount in smallest currency unit
+      # @param currency [String] Currency code (e.g., 'KES') - REQUIRED
+      # @param account_reference [String] Account reference for the transaction
+      # @param options [Hash] Additional options (description, metadata, etc.)
+      # @return [Hash] STK push response with checkout_request_id
+      def mpesa_stk_push(phone_number:, amount:, currency:, account_reference:, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/mobile-money/mpesa/stk-push", {
+          phone_number: phone_number,
+          amount: amount,
+          currency: currency,
+          account_reference: account_reference,
+          **options
+        })
+      end
+
+      # Check M-Pesa STK Push status
+      #
+      # @param checkout_request_id [String] The checkout request ID from stk_push
+      # @return [Hash] Transaction status
+      def mpesa_status(checkout_request_id)
+        @client.get("/mobile-money/mpesa/status/#{checkout_request_id}")
+      end
+
+      # M-Pesa B2C (payouts)
+      #
+      # @param phone_number [String] Recipient phone number
+      # @param amount [Integer] Amount to send
+      # @param currency [String] Currency code - REQUIRED
+      # @param options [Hash] Additional options
+      # @return [Hash] B2C response
+      def mpesa_b2c(phone_number:, amount:, currency:, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/mobile-money/mpesa/b2c", {
+          phone_number: phone_number,
+          amount: amount,
+          currency: currency,
+          **options
+        })
+      end
+
+      # MTN Mobile Money collection
+      #
+      # @param phone_number [String] Customer phone number
+      # @param amount [Integer] Amount to collect
+      # @param currency [String] Currency code (e.g., 'UGX') - REQUIRED
+      # @param options [Hash] Additional options
+      # @return [Hash] Collection response
+      def mtn_collect(phone_number:, amount:, currency:, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/mobile-money/mtn/collect", {
+          phone_number: phone_number,
+          amount: amount,
+          currency: currency,
+          **options
+        })
+      end
+
+      # Airtel Money collection
+      #
+      # @param phone_number [String] Customer phone number
+      # @param amount [Integer] Amount to collect
+      # @param currency [String] Currency code - REQUIRED
+      # @param options [Hash] Additional options
+      # @return [Hash] Collection response
+      def airtel_collect(phone_number:, amount:, currency:, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/mobile-money/airtel/collect", {
+          phone_number: phone_number,
+          amount: amount,
+          currency: currency,
+          **options
+        })
+      end
+    end
+  end
+end

data/lib/sunny/resources/payments.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # Payments resource for creating and managing payments
+    class Payments
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a new payment
+      #
+      # @param amount [Integer] Amount in smallest currency unit
+      # @param currency [String] Currency code (e.g., 'KES', 'USD', 'UGX') - REQUIRED
+      # @param source [String] Payment source (e.g., 'mpesa', 'card')
+      # @param options [Hash] Additional options
+      # @return [Hash] Created payment object
+      def create(amount:, currency:, source:, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        @client.post("/payments", {
+          amount: amount,
+          currency: currency,
+          source: source,
+          **options
+        })
+      end
+
+      # Retrieve a payment by ID
+      #
+      # @param payment_id [String] The payment ID
+      # @return [Hash] Payment object
+      def retrieve(payment_id)
+        @client.get("/payments/#{payment_id}")
+      end
+
+      # List payments
+      #
+      # @param params [Hash] Query parameters (limit, starting_after, etc.)
+      # @return [Hash] List of payments with pagination info
+      def list(**params)
+        @client.get("/payments", params)
+      end
+
+      # Capture a payment
+      #
+      # @param payment_id [String] The payment ID
+      # @param amount [Integer, nil] Amount to capture (optional, captures full amount if nil)
+      # @return [Hash] Captured payment object
+      def capture(payment_id, amount: nil)
+        body = amount ? { amount: amount } : {}
+        @client.post("/payments/#{payment_id}/capture", body)
+      end
+
+      # Refund a payment
+      #
+      # @param payment_id [String] The payment ID
+      # @param amount [Integer, nil] Amount to refund (optional, full refund if nil)
+      # @param reason [String, nil] Reason for refund
+      # @return [Hash] Refund object
+      def refund(payment_id, amount: nil, reason: nil)
+        body = {}
+        body[:amount] = amount if amount
+        body[:reason] = reason if reason
+        @client.post("/payments/#{payment_id}/refund", body)
+      end
+    end
+  end
+end

data/lib/sunny/resources/qr_codes.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # QR Codes resource
+    class QRCodes
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a QR code
+      #
+      # @param type [String] QR type ('static' or 'dynamic')
+      # @param amount [Integer, nil] Amount (required for dynamic)
+      # @param currency [String] Currency code - REQUIRED
+      # @param options [Hash] Additional options
+      def create(type:, currency:, amount: nil, **options)
+        raise ValidationError.new("currency is required", field: "currency") if currency.nil? || currency.empty?
+        
+        body = { type: type, currency: currency, **options }
+        body[:amount] = amount if amount
+        @client.post("/qr-codes", body)
+      end
+
+      # Retrieve a QR code
+      def retrieve(qr_id)
+        @client.get("/qr-codes/#{qr_id}")
+      end
+
+      # List QR codes
+      def list(**params)
+        @client.get("/qr-codes", params)
+      end
+
+      # Deactivate a QR code
+      def deactivate(qr_id)
+        @client.post("/qr-codes/#{qr_id}/deactivate", {})
+      end
+    end
+  end
+end

data/lib/sunny/resources/refunds.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # Refunds resource
+    class Refunds
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a refund
+      def create(payment_id:, amount: nil, reason: nil)
+        body = { payment_id: payment_id }
+        body[:amount] = amount if amount
+        body[:reason] = reason if reason
+        @client.post("/refunds", body)
+      end
+
+      # Retrieve a refund
+      def retrieve(refund_id)
+        @client.get("/refunds/#{refund_id}")
+      end
+
+      # List refunds
+      def list(**params)
+        @client.get("/refunds", params)
+      end
+    end
+  end
+end

data/lib/sunny/resources/virtual_accounts.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sunny
+  module Resources
+    # Virtual Accounts resource
+    class VirtualAccounts
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a virtual account
+      def create(customer_email:, **options)
+        @client.post("/virtual-accounts", {
+          customer_email: customer_email,
+          **options
+        })
+      end
+
+      # Retrieve a virtual account
+      def retrieve(account_id)
+        @client.get("/virtual-accounts/#{account_id}")
+      end
+
+      # List virtual accounts
+      def list(**params)
+        @client.get("/virtual-accounts", params)
+      end
+
+      # Close a virtual account
+      def close(account_id)
+        @client.post("/virtual-accounts/#{account_id}/close", {})
+      end
+    end
+  end
+end

data/lib/sunny/resources/webhooks.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Sunny
+  module Resources
+    # Webhooks resource
+    class Webhooks
+      def initialize(client)
+        @client = client
+      end
+
+      # Register a webhook endpoint
+      def create(url:, events:, **options)
+        @client.post("/webhooks", {
+          url: url,
+          events: events,
+          **options
+        })
+      end
+
+      # Retrieve a webhook
+      def retrieve(webhook_id)
+        @client.get("/webhooks/#{webhook_id}")
+      end
+
+      # List webhooks
+      def list(**params)
+        @client.get("/webhooks", params)
+      end
+
+      # Update a webhook
+      def update(webhook_id, **attributes)
+        @client.put("/webhooks/#{webhook_id}", attributes)
+      end
+
+      # Delete a webhook
+      def delete(webhook_id)
+        @client.delete("/webhooks/#{webhook_id}")
+      end
+
+      # Verify webhook signature
+      #
+      # @param payload [String] Raw request body
+      # @param signature [String] X-Sunny-Signature header value
+      # @param secret [String] Your webhook secret
+      # @return [Boolean] Whether signature is valid
+      def self.verify_signature(payload, signature, secret)
+        expected = OpenSSL::HMAC.hexdigest("SHA256", secret, payload)
+        secure_compare(expected, signature)
+      end
+
+      # Constant-time string comparison
+      def self.secure_compare(a, b)
+        return false unless a.bytesize == b.bytesize
+
+        result = 0
+        a.bytes.zip(b.bytes) { |x, y| result |= x ^ y }
+        result.zero?
+      end
+    end
+  end
+end

data/lib/sunny/version.rb

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

data/lib/sunny.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "sunny/version"
+require_relative "sunny/errors"
+require_relative "sunny/client"
+require_relative "sunny/resources/payments"
+require_relative "sunny/resources/customers"
+require_relative "sunny/resources/mobile_money"
+require_relative "sunny/resources/invoices"
+require_relative "sunny/resources/bills"
+require_relative "sunny/resources/qr_codes"
+require_relative "sunny/resources/crypto"
+require_relative "sunny/resources/webhooks"
+require_relative "sunny/resources/refunds"
+require_relative "sunny/resources/virtual_accounts"
+require_relative "sunny/resources/bnpl"
+
+module Sunny
+  class << self
+    attr_accessor :api_key, :api_base
+
+    def configure
+      yield self
+    end
+  end
+
+  self.api_base = ENV["SUNNY_API_URL"] || "https://api.sunnypay.co.ke/v1"
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: sunny-payments
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Sunny Pay Team
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Accept Mobile money, cards, crypto, invoices, QR codes, and more with
+  Sunny Payments.
+email:
+- dev@sunnypay.co.ke
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/sunny.rb
+- lib/sunny/client.rb
+- lib/sunny/errors.rb
+- lib/sunny/resources/bills.rb
+- lib/sunny/resources/bnpl.rb
+- lib/sunny/resources/crypto.rb
+- lib/sunny/resources/customers.rb
+- lib/sunny/resources/invoices.rb
+- lib/sunny/resources/mobile_money.rb
+- lib/sunny/resources/payments.rb
+- lib/sunny/resources/qr_codes.rb
+- lib/sunny/resources/refunds.rb
+- lib/sunny/resources/virtual_accounts.rb
+- lib/sunny/resources/webhooks.rb
+- lib/sunny/version.rb
+homepage: https://sunnypay.co.ke
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://sunnypay.co.ke
+  source_code_uri: https://github.com/SUNNYPAY-LIMITED/Sunny-Ruby-SDK
+  changelog_uri: https://github.com/SUNNYPAY-LIMITED/Sunny-Ruby-SDK/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Official Ruby SDK for Sunny Payments
+test_files: []