solidgate-ruby-sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea4cb6a76307e222aa86375dba8378cf9591d8d66e1512805f5cab04466ab8d2
+  data.tar.gz: 8ee67abaf5dbb9fb2ad4fe00824d8da9f2ba776673322c26de61a1cd5f44c248
+SHA512:
+  metadata.gz: db9bd5aeb1d91aad532f50f327059c00251fb9cb6bf8d68c373281dec6633800e33393a0ac1b757858b42604800df23dddd58e41feea498fa135ffaeee3207cc
+  data.tar.gz: a82dc9a15b3997cc5fdc34fc587e8ebb3b2eba3887984117a4ce7c8d72af020b86177b7ffc5662d0ac42afb77d948f1c843aeae334de7b87e9809ad343047ad5

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.7.6

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2025-12-18
+
+### Added
+- Initial release of the Solidgate Ruby SDK
+- Payment creation, retrieval, capture, void, and refund functionality
+- Subscription management (basic structure)
+- Comprehensive error handling with specific error classes
+- Configuration management for API credentials and environment settings
+- HTTP client with proper authentication and signature generation
+- Support for both sandbox and production environments
+- RSpec test suite foundation
+
+### Features
+- Support for all major payment operations
+- Automatic request signing using SHA-1 + Base64
+- Configurable timeouts and connection settings
+- Detailed error messages and codes
+- Thread-safe configuration
+- Comprehensive documentation and examples
+
+[Unreleased]: https://github.com/cgtrader/solidgate-ruby-sdk/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/cgtrader/solidgate-ruby-sdk/releases/tag/v0.1.0

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in solidgate.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+group :development, :test do
+  gem "pry"
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    solidgate-ruby-sdk (0.1.0)
+      faraday
+      faraday-multipart
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    base64 (0.3.0)
+    coderay (1.1.3)
+    faraday (2.8.1)
+      base64
+      faraday-net_http (>= 2.0, < 3.1)
+      ruby2_keywords (>= 0.0.4)
+    faraday-multipart (1.1.1)
+      multipart-post (~> 2.0)
+    faraday-net_http (3.0.2)
+    method_source (1.1.0)
+    multipart-post (2.4.1)
+    pry (0.15.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.3.1)
+    ruby2_keywords (0.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  rake (~> 13.0)
+  solidgate-ruby-sdk!
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 CGTrader
+
+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,96 @@
+# Solidgate Ruby SDK
+
+A Ruby (unofficial) SDK for integrating with the Solidgate payment gateway API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'solidgate'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install solidgate
+
+## Configuration
+
+Configure the SDK with your Solidgate credentials in an initializer file:
+
+```ruby
+Solidgate.configure do |config|
+  config.public_key = 'your_public_key'
+  config.private_key = 'your_private_key'
+  config.webhook_public_key = 'your_webhook_public_key'
+  config.webhook_private_key = 'your_webhook_private_key'
+  config.sandbox = true
+end
+```
+
+## Usage
+
+### Creating a Payment
+
+```ruby
+client = Solidgate::Client.new
+
+payment_intent = {
+  order_id:            'order_id_123', # Unique order identifier provided by the merchant
+  product_id:          'product_id_456', # Product identifier generated in Solidgate Dashboard
+  customer_account_id: 'customer_789', # Unique customer identifier provided by the merchant
+  order_description:   'Premium package',
+  type:                'auth',
+  settle_interval:     0, # delay in hours for automatic settlement, 0 means immediate settlement
+  retry_attempt:       3,
+  language:            I18n.locale # language to render the payment form
+}.to_json
+
+encrypted_payment_intent = client.generate_intent(payment_intent)
+
+# use the payment_data in your FE to render the payment form
+
+payment_data = {
+  merchant:      Solidgate.configuration.public_key,
+  signature:     SolidgateClient.generate_signature(encrypted_payment_intent),
+  paymentIntent: encrypted_payment_intent
+}
+```
+
+### Handling Webhooks
+
+```ruby
+  payload = request.body.read
+  Solidgate::Webhook.new.validate_signature(payload, request.headers['Signature']) # returns true/false to verify the webhook
+```
+
+
+## Available Error Classes
+
+- `Solidgate::Error` - Base error class
+- `Solidgate::ConfigurationError` - Configuration issues
+- `Solidgate::ValidationError` - Parameter validation errors
+- `Solidgate::AuthenticationError` - Authentication failures
+- `Solidgate::InvalidRequestError` - Invalid request parameters
+- `Solidgate::APIError` - General API errors
+- `Solidgate::ConnectionError` - Network connectivity issues
+- `Solidgate::TimeoutError` - Request timeout
+- `Solidgate::RateLimitError` - Rate limit exceeded
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cgtrader/solidgate-ruby-sdk.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "rake"
+# require "rspec/core/rake_task"
+
+# RSpec::Core::RakeTask.new(:spec)
+
+require "bundler/gem_tasks"
+
+task default: :spec

data/examples/basic_usage.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example usage of the Solidgate Ruby SDK
+
+require_relative "../lib/solidgate"
+
+# Configure the SDK
+Solidgate.configure do |config|
+  config.public_key = ENV["SOLIDGATE_PUBLIC_KEY"] || "your_public_key_here"
+  config.private_key = ENV["SOLIDGATE_PRIVATE_KEY"] || "your_private_key_here"
+  config.sandbox = true # Use sandbox for testing
+end
+
+begin
+  # Create a payment instance
+  payment = Solidgate::Payment.new
+
+  puts "=== Creating a Payment ==="
+  
+  # Create a new payment
+  payment_params = {
+    order_id: "example_order_#{Time.now.to_i}",
+    amount: 1000, # $10.00 in cents
+    currency: "USD",
+    card_data: {
+      number: "4111111111111111",      # Test card number
+      exp_month: "12",
+      exp_year: "2025",
+      cvv: "123"
+    },
+    customer: {
+      email: "customer@example.com",
+      first_name: "John",
+      last_name: "Doe"
+    },
+    description: "Test payment from Ruby SDK example"
+  }
+  
+  payment_response = payment.create(payment_params)
+  puts "Payment created successfully!"
+  puts "Payment ID: #{payment_response['payment_id']}"
+  puts "Status: #{payment_response['status']}"
+  
+  payment_id = payment_response["payment_id"]
+  
+  # Get payment details
+  puts "\n=== Getting Payment Details ==="
+  payment_details = payment.get(payment_id)
+  puts "Payment Amount: #{payment_details['amount']}"
+  puts "Payment Status: #{payment_details['status']}"
+  
+  # Capture the payment (if it was authorized)
+  if payment_details["status"] == "authorized"
+    puts "\n=== Capturing Payment ==="
+    capture_response = payment.capture(payment_id)
+    puts "Payment captured successfully!"
+    puts "Capture Status: #{capture_response['status']}"
+  end
+  
+  # Example of partial refund
+  if payment_details["status"] == "captured" || payment_details["status"] == "succeeded"
+    puts "\n=== Refunding Payment (Partial) ==="
+    refund_response = payment.refund(payment_id, amount: 500, reason: "Partial refund example")
+    puts "Refund processed successfully!"
+    puts "Refund Amount: #{refund_response['amount']}"
+    puts "Refund Status: #{refund_response['status']}"
+  end
+
+rescue Solidgate::ValidationError => e
+  puts "❌ Validation Error: #{e.message}"
+  puts "Errors: #{e.errors}"
+rescue Solidgate::AuthenticationError => e
+  puts "❌ Authentication Error: #{e.message}"
+  puts "Please check your API credentials"
+rescue Solidgate::APIError => e
+  puts "❌ API Error: #{e.message}"
+  puts "Error Code: #{e.code}" if e.code
+  puts "HTTP Status: #{e.http_status}" if e.http_status
+rescue Solidgate::ConnectionError => e
+  puts "❌ Connection Error: #{e.message}"
+  puts "Please check your internet connection"
+rescue Solidgate::Error => e
+  puts "❌ Solidgate Error: #{e.message}"
+rescue => e
+  puts "❌ Unexpected Error: #{e.message}"
+  puts e.backtrace if ENV["DEBUG"]
+end

data/lib/solidgate/client.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "json"
+require "digest"
+require "base64"
+require "openssl"
+require 'pry'
+
+module Solidgate
+  # HTTP client for interacting with the Solidgate API
+  class Client
+    attr_reader :config
+
+    IV_LENGTH = 16
+    KEY_LENGTH = 32
+
+    def initialize(options = Solidgate.configuration)
+      @config = build_config(options)
+      @config.validate!
+    end
+
+    # Create a new payment
+    #
+    # @param params [Hash] payment parameters
+    # @return [Hash] payment response
+    def create_payment(params)
+      post("/v1/charge", params)
+    end
+
+    # Get payment status
+    #
+    # @param payment_id [String] payment ID
+    # @return [Hash] payment details
+    def get_payment(payment_id)
+      get("/v1/charge/#{payment_id}")
+    end
+
+    # Capture a payment
+    #
+    # @param payment_id [String] payment ID
+    # @param params [Hash] capture parameters (optional)
+    # @return [Hash] capture response
+    def capture_payment(payment_id, params = {})
+      post("/v1/charge/#{payment_id}/capture", params)
+    end
+
+    # Void a payment
+    #
+    # @param payment_id [String] payment ID
+    # @return [Hash] void response
+    def void_payment(payment_id)
+      post("/v1/charge/#{payment_id}/void")
+    end
+
+    # Refund a payment
+    #
+    # @param payment_id [String] payment ID
+    # @param params [Hash] refund parameters
+    # @return [Hash] refund response
+    def refund_payment(payment_id, params = {})
+      post("/v1/charge/#{payment_id}/refund", params)
+    end
+
+    # Settle a payment
+    #
+    # @param params [Hash] settlement parameters
+    # @return [Hash] settlement response
+    def settle_payment(params = {})
+      conifg.api_url
+    end
+
+    # Create a subscription
+    #
+    # @param params [Hash] subscription parameters
+    # @return [Hash] subscription response
+    def create_subscription(params)
+      post("/v1/subscription", params)
+    end
+
+    # Get subscription details
+    #
+    # @param subscription_id [String] subscription ID
+    # @return [Hash] subscription details
+    def subscription_status(subscription_id)
+      post("api/v1/subscription/status", { subscription_id: subscription_id })
+    end
+
+    def create_product(params)
+      post("/api/v1/products", params)
+    end
+
+    def products
+      get("/api/v1/products")
+    end
+
+    def product_prices(product_id)
+      get("/api/v1/products/#{product_id}/prices")
+    end
+
+    def generate_intent(params)
+      encrypt_payload(params)
+    end
+
+    def generate_signature(json_string, public_key: config.public_key, private_key: config.private_key)
+      digest = OpenSSL::Digest.new('sha512')
+      instance = OpenSSL::HMAC.new(private_key, digest)
+      instance.update(public_key + json_string + public_key)
+      Base64.strict_encode64(instance.hexdigest)
+    end
+
+    private
+
+    def build_config(options)
+      if options.is_a?(Configuration)
+        options
+      else
+        config = Configuration.new
+        options.each { |key, value| config.send("#{key}=", value) if config.respond_to?("#{key}=") }
+        config
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new(
+        url: config.api_url,
+        headers: default_headers
+      ) do |conn|
+        conn.request :multipart
+        conn.request :url_encoded
+        conn.response :json, content_type: /\bjson$/
+        conn.adapter Faraday.default_adapter
+
+        conn.options.timeout = config.timeout
+        conn.options.open_timeout = config.open_timeout
+      end
+    end
+
+    def default_headers
+      {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json",
+        "User-Agent" => config.user_agent
+      }
+    end
+
+    def get(path)
+      request(:get, path)
+    end
+
+    def post(path, body = {})
+      request(:post, path, body)
+    end
+
+    def request(method, path, body = nil)
+      body_json = body ? JSON.generate(body) : ''
+      signature = generate_signature(body_json)
+
+      response = connection.send(method) do |req|
+        req.url path
+        req.headers["Merchant"] = config.public_key
+        req.headers["Signature"] = signature
+        req.body = body_json if body_json
+      end
+
+      handle_response(response)
+    rescue Faraday::TimeoutError
+      raise TimeoutError, "Request timed out"
+    rescue Faraday::ConnectionFailed => e
+      raise ConnectionError, "Connection failed: #{e.message}"
+    rescue => e
+      raise Error, "Unexpected error: #{e.message}"
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        response.body
+      when 400
+        raise InvalidRequestError.new(
+          extract_error_message(response),
+          extract_error_code(response),
+          response.body,
+          response.status
+        )
+      when 401
+        raise AuthenticationError.new(
+          "Authentication failed",
+          "authentication_failed",
+          response.body,
+          response.status
+        )
+      when 429
+        raise RateLimitError.new(
+          "Rate limit exceeded",
+          "rate_limit_exceeded",
+          response.body,
+          response.status
+        )
+      when 500..599
+        raise APIError.new(
+          "Server error",
+          "server_error",
+          response.body,
+          response.status
+        )
+      else
+        raise APIError.new(
+          "Unknown error",
+          "unknown_error",
+          response.body,
+          response.status
+        )
+      end
+    end
+
+    def extract_error_message(response)
+      return "Unknown error" unless response.body.is_a?(Hash)
+
+      response.body["error"]["message"] || "API error"
+    rescue
+      "Unknown error"
+    end
+
+    def extract_error_code(response)
+      return nil unless response.body.is_a?(Hash)
+
+      response.body["error"]["code"]
+    rescue
+      nil
+    end
+
+    def encrypt_payload(attributes)
+      key = config.private_key[0, KEY_LENGTH]
+      iv = OpenSSL::Random.random_bytes(IV_LENGTH)
+      cipher = OpenSSL::Cipher.new('aes-256-cbc')
+      cipher.encrypt
+      cipher.key = key
+      cipher.iv = iv
+      encrypted = cipher.update(attributes) + cipher.final
+
+      base64_encoded = Base64.urlsafe_encode64(iv + encrypted)
+      base64_encoded.gsub('+', '-').gsub('/', '_')
+    end
+  end
+end

data/lib/solidgate/configuration.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Solidgate
+  # Configuration class for the Solidgate SDK
+  class Configuration
+    # @!attribute [rw] public_key
+    #   @return [String] Solidgate public key
+    attr_accessor :public_key
+
+    # @!attribute [rw] private_key
+    #   @return [String] Solidgate private key
+    attr_accessor :private_key
+
+    # @!attribute [rw] sandbox
+    #   @return [Boolean] whether to use sandbox environment
+    attr_accessor :sandbox
+
+    # @!attribute [rw] api_url
+    #   @return [String] API base URL
+    attr_accessor :api_url
+
+    # @!attribute [rw] timeout
+    #   @return [Integer] request timeout in seconds
+    attr_accessor :timeout
+
+    # @!attribute [rw] open_timeout
+    #   @return [Integer] connection timeout in seconds
+    attr_accessor :open_timeout
+
+    # @!attribute [rw] user_agent
+    #   @return [String] custom user agent
+    attr_accessor :user_agent
+    
+    # @!attribute [rw] webhook_public_key
+    #   @return [String] Webhook public key
+    attr_accessor :webhook_public_key
+
+    # @!attribute [rw] webhook_private_key
+    #   @return [String] Webhook private key
+    attr_accessor :webhook_private_key
+
+    # Production API URL
+    PRODUCTION_URL = "https://subscriptions.solidgate.com"
+
+    # Sandbox API URL
+    SANDBOX_URL = "https://subscriptions.solidgate.com"
+
+    def initialize
+      @sandbox = false
+      @timeout = 30
+      @open_timeout = 10
+      @user_agent = "Solidgate Ruby SDK/#{VERSION}"
+    end
+
+    # Get the appropriate API URL based on sandbox setting
+    #
+    # @return [String] API base URL
+    def api_url
+      @api_url || (sandbox? ? SANDBOX_URL : PRODUCTION_URL)
+    end
+
+    # Check if sandbox mode is enabled
+    #
+    # @return [Boolean] true if sandbox mode is enabled
+    def sandbox?
+      @sandbox
+    end
+
+    # Validate that required configuration is present
+    #
+    # @raise [ConfigurationError] if required configuration is missing
+    def validate!
+      raise ConfigurationError, "public_key is required" unless public_key
+      raise ConfigurationError, "private_key is required" unless private_key
+    end
+  end
+end

data/lib/solidgate/errors.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Solidgate
+  # Base error class for all Solidgate errors
+  class Error < StandardError
+    attr_reader :code, :details
+
+    def initialize(message = nil, code = nil, details = nil)
+      super(message)
+      @code = code
+      @details = details
+    end
+  end
+
+  # Configuration error
+  class ConfigurationError < Error; end
+
+  # API error
+  class APIError < Error
+    def initialize(message, code, details = nil, http_status = nil)
+      super(message, code, details)
+      @http_status = http_status
+    end
+
+    attr_reader :http_status
+  end
+
+  # Authentication error
+  class AuthenticationError < APIError; end
+
+  # Invalid request error
+  class InvalidRequestError < APIError; end
+
+  # Connection error
+  class ConnectionError < Error; end
+
+  # Timeout error
+  class TimeoutError < Error; end
+
+  # Rate limit error
+  class RateLimitError < APIError; end
+
+  # Validation error
+  class ValidationError < Error
+    attr_reader :errors
+
+    def initialize(message, errors = {})
+      super(message)
+      @errors = errors
+    end
+  end
+end

data/lib/solidgate/payment.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Solidgate
+  # Payment resource for handling payment-related operations
+  class Payment
+    attr_reader :client
+
+    def initialize(client = nil)
+      @client = client || Solidgate.client
+    end
+
+    # Create a new payment charge
+    #
+    # @param params [Hash] payment parameters
+    # @option params [String] :order_id unique order identifier
+    # @option params [Integer] :amount amount in cents
+    # @option params [String] :currency currency code (e.g., "USD")
+    # @option params [Hash] :card_data card information
+    # @option params [Hash] :customer customer information
+    # @option params [String] :description payment description
+    # @return [Hash] payment response
+    def create(params)
+      validate_create_params(params)
+      client.create_payment(params)
+    end
+
+    # Retrieve payment information
+    #
+    # @param payment_id [String] payment ID
+    # @return [Hash] payment details
+    def get(payment_id)
+      raise ArgumentError, "payment_id is required" if payment_id.nil? || payment_id.empty?
+      
+      client.get_payment(payment_id)
+    end
+
+    # Capture a previously authorized payment
+    #
+    # @param payment_id [String] payment ID
+    # @param amount [Integer] amount to capture in cents (optional, defaults to full amount)
+    # @return [Hash] capture response
+    def capture(payment_id, amount: nil)
+      raise ArgumentError, "payment_id is required" if payment_id.nil? || payment_id.empty?
+      
+      params = {}
+      params[:amount] = amount if amount
+      
+      client.capture_payment(payment_id, params)
+    end
+
+    # Void a payment (cancel an authorization)
+    #
+    # @param payment_id [String] payment ID
+    # @return [Hash] void response
+    def void(payment_id)
+      raise ArgumentError, "payment_id is required" if payment_id.nil? || payment_id.empty?
+      
+      client.void_payment(payment_id)
+    end
+
+    # Refund a payment (full or partial)
+    #
+    # @param payment_id [String] payment ID
+    # @param amount [Integer] amount to refund in cents (optional, defaults to full amount)
+    # @param reason [String] refund reason (optional)
+    # @return [Hash] refund response
+    def refund(payment_id, amount: nil, reason: nil)
+      raise ArgumentError, "payment_id is required" if payment_id.nil? || payment_id.empty?
+      
+      params = {}
+      params[:amount] = amount if amount
+      params[:reason] = reason if reason
+      
+      client.refund_payment(payment_id, params)
+    end
+
+    private
+
+    def validate_create_params(params)
+      errors = {}
+
+      errors[:order_id] = "is required" unless params[:order_id]
+      errors[:amount] = "is required" unless params[:amount]
+      errors[:currency] = "is required" unless params[:currency]
+      
+      if params[:amount] && params[:amount] <= 0
+        errors[:amount] = "must be greater than 0"
+      end
+
+      if params[:currency] && params[:currency].length != 3
+        errors[:currency] = "must be a 3-letter currency code"
+      end
+
+      unless errors.empty?
+        raise ValidationError.new("Invalid payment parameters", errors)
+      end
+    end
+  end
+end

data/lib/solidgate/version.rb

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

data/lib/solidgate/webhook.rb

@@ -0,0 +1,20 @@
+module Solidgate
+  class Webhook
+    # Webhook resource for handling webhook-related operations
+    attr_reader :client
+
+    def initialize(client = nil)
+      @client = client || Solidgate.client
+    end
+
+    # Validate webhook signature
+    # @param payload [String] webhook payload
+    # @param signature [String] webhook signature
+    # @return [Boolean] whether the signature is valid
+    def validate_signature(payload, signature)
+      client.generate_signature(payload,
+                                 public_key: Solidgate.configuration.webhook_public_key,
+                                 private_key: Solidgate.configuration.webhook_private_key) == signature
+    end
+  end
+end

data/lib/solidgate.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "solidgate/version"
+require_relative "solidgate/configuration"
+require_relative "solidgate/errors"
+require_relative "solidgate/client"
+require_relative "solidgate/payment"
+require_relative "solidgate/webhook"
+
+module Solidgate
+  class << self
+    # Configure the Solidgate client
+    #
+    # @yield [Configuration] configuration object
+    # @example
+    #   Solidgate.configure do |config|
+    #     config.public_key = "your_public_key"
+    #     config.private_key = "your_private_key"
+    #     config.sandbox = true
+    #   end
+    def configure
+      yield(configuration)
+    end
+
+    # Current configuration
+    #
+    # @return [Configuration] current configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Create a new client instance
+    #
+    # @param options [Hash] optional configuration overrides
+    # @return [Client] new client instance
+    def client
+      Client.new
+    end
+  end
+end

data/solidgate.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "lib/solidgate/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "solidgate-ruby-sdk"
+  spec.version = Solidgate::VERSION
+  spec.authors = ["Hector Carrillo"]
+  spec.email = ["carrfane@gmail.com"]
+  
+  spec.summary = "Ruby SDK for Solidgate payment processing"
+  spec.description = "A Ruby SDK for integrating with the Solidgate payment gateway API"
+  spec.homepage = "https://github.com/carrfane/solidgate-ruby-sdk"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+  
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/carrfane/solidgate-ruby-sdk"
+  spec.metadata["changelog_uri"] = "https://github.com/carrfane/solidgate-ruby-sdk/blob/master/CHANGELOG.md"
+  
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end
+  end
+  
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  # Runtime dependencies
+  spec.add_dependency "faraday"
+  spec.add_dependency "faraday-multipart"
+  
+  # Development dependencies
+  # spec.add_development_dependency "rspec", "~> 3.0"
+  # spec.add_development_dependency "webmock", "~> 3.0"
+  # spec.add_development_dependency "vcr", "~> 6.0"
+  # spec.add_development_dependency "rubocop", "~> 1.0"
+  # spec.add_development_dependency "pry", "~> 0.14"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: solidgate-ruby-sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hector Carrillo
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby SDK for integrating with the Solidgate payment gateway API
+email:
+- carrfane@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/basic_usage.rb
+- lib/solidgate.rb
+- lib/solidgate/client.rb
+- lib/solidgate/configuration.rb
+- lib/solidgate/errors.rb
+- lib/solidgate/payment.rb
+- lib/solidgate/version.rb
+- lib/solidgate/webhook.rb
+- solidgate.gemspec
+homepage: https://github.com/carrfane/solidgate-ruby-sdk
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/carrfane/solidgate-ruby-sdk
+  source_code_uri: https://github.com/carrfane/solidgate-ruby-sdk
+  changelog_uri: https://github.com/carrfane/solidgate-ruby-sdk/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Ruby SDK for Solidgate payment processing
+test_files: []