fluvpay 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 336ce87416d2b68762b6c5179c4649d20544be466896a07054a41ecabf90622c
+  data.tar.gz: f5d12643b1c4f94428c162b2faf30fd440a1d84c001bcc0a896953158258400c
+SHA512:
+  metadata.gz: 487229bdf46c7981f5f445fc8acb37b5c0704f479b65f4f33ef45cacaded33ba8117a0b95a342d06693fe7b3df8137c3b37524ce2f57c869ac75a4c6e8811ba6
+  data.tar.gz: a15480e1fd9c33bb090844e89fb9aa0901349a8043043c5414bba49e8413ddb5da0bc523515689aa6c273740518c410668ed0f4109c49ba1693eec559fa976e8

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FluvPay
+
+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,268 @@
+# FluvPay Ruby
+
+SDK oficial da FluvPay para Ruby. Cobre cobranças PIX, saques, transferências internas e verificação de webhooks, com erros tipados e tratamento idiomático. A interface é estável e previsível, adequada tanto a integrações operadas por pessoas quanto a agentes que consomem a API de forma programática.
+
+- Requer Ruby 3.0 ou superior.
+- O cliente HTTP é construído sobre a biblioteca padrão (`net/http`). Não há dependências de runtime.
+- Inclui retentativas automáticas em operações seguras, geração automática de `Idempotency-Key` e erros tipados por classe.
+
+## Instalação
+
+A publicação no RubyGems está pendente. Por enquanto, instale a partir do repositório, fixando a tag para builds reproduzíveis. No `Gemfile`:
+
+```ruby
+gem "fluvpay", git: "https://github.com/fluvpay/fluvpay-ruby", tag: "v1.0.0"
+```
+
+E execute:
+
+```bash
+bundle install
+```
+
+Substituir `tag:` por `branch: "main"` acompanha o desenvolvimento em curso, com a ressalva de que a `main` pode mudar a qualquer momento.
+
+### RubyGems (em breve)
+
+Quando a gem for publicada no RubyGems, a instalação passará a ser `gem install fluvpay` (ou `gem "fluvpay"` no `Gemfile`). Até lá, esses comandos não resolvem.
+
+Para construir a gem a partir do código-fonte sem um `Gemfile`:
+
+```bash
+git clone --branch v1.0.0 https://github.com/fluvpay/fluvpay-ruby.git
+cd fluvpay-ruby
+gem build fluvpay.gemspec
+gem install ./fluvpay-1.0.0.gem
+```
+
+## Início rápido
+
+```ruby
+require "fluvpay"
+
+client = FluvPay::Client.new(api_key: "fluv_test_sua_chave_de_teste")
+
+charge = client.charges.create(
+  amount_cents: 5000,
+  description: "Pedido 123",
+  customer: { name: "Maria", email: "maria@exemplo.com" },
+  metadata: { pedido_id: "123" }
+)
+
+puts charge["id"]
+puts charge["pix_copy_paste"]
+```
+
+## Autenticação
+
+A autenticação usa a API Key informada no construtor do cliente. O ambiente é determinado pelo prefixo da chave: `fluv_live_` seleciona produção e `fluv_test_` seleciona o sandbox.
+
+```ruby
+require "fluvpay"
+
+client = FluvPay::Client.new(api_key: "fluv_live_sua_chave_aqui")
+```
+
+A base URL padrão é `https://api.fluvpay.com/api/v1`. Para sobrescrevê-la, informe `base_url:` no construtor.
+
+## Exemplo completo
+
+O exemplo a seguir cria uma cobrança, recupera o registro, lista com paginação e verifica a assinatura de um webhook recebido.
+
+```ruby
+require "fluvpay"
+
+client = FluvPay::Client.new(api_key: "fluv_test_sua_chave_de_teste")
+
+# Criar uma cobrança PIX. O valor é informado em centavos.
+# A Idempotency-Key é gerada automaticamente quando não fornecida.
+begin
+  charge = client.charges.create(
+    amount_cents: 5000,
+    description: "Pedido 123",
+    customer: { name: "Maria", email: "maria@exemplo.com" },
+    metadata: { pedido_id: "123" }
+  )
+rescue FluvPay::ValidationError => err
+  puts "Dados inválidos: #{err.code} #{err.message}"
+  err.details.each { |d| puts " - #{d['field']} #{d['message']}" }
+  raise
+end
+
+puts "Cobrança criada: #{charge['id']} #{charge['status']}"
+puts "Copia e cola PIX: #{charge['pix_copy_paste']}"
+
+# Recuperar pela ID.
+mesma = client.charges.retrieve(charge["id"])
+puts "Status atual: #{mesma['status']}"
+
+# Listar cobranças com paginação page/per_page.
+pagina = client.charges.list(page: 1, per_page: 20, status: "paid")
+puts "Página #{pagina.page} de #{pagina.total} cobranças, há mais? #{pagina.has_next?}"
+pagina.each { |item| puts " - #{item['id']} #{item['amount_cents']} #{item['status']}" }
+
+# Verificar a assinatura de um webhook recebido.
+# A verificação usa o corpo cru da requisição, nunca o JSON re-serializado.
+def handle_webhook(raw_body, headers)
+  event = FluvPay::Webhooks.verify_signature(
+    raw_body,
+    headers["X-FluvPay-Signature"],
+    headers["X-FluvPay-Timestamp"],
+    "whsec_seu_segredo_do_webhook",
+    event_type: headers["X-FluvPay-Event"],
+    delivery_id: headers["X-FluvPay-Delivery-Id"],
+    tolerance_seconds: 300
+  )
+  puts "Cobrança paga: #{event.data['id']}" if event.type == "charge.paid"
+end
+```
+
+## Referência de recursos
+
+### Charges (cobranças PIX)
+
+```ruby
+client.charges.create(amount_cents:, idempotency_key: nil, **campos)  # POST /charges/
+client.charges.retrieve(charge_id)                                    # GET  /charges/{id}
+client.charges.list(page:, per_page:, sort:, status:)                 # GET  /charges/
+```
+
+### Transactions (extrato)
+
+```ruby
+client.transactions.list(page:, per_page:, sort:)   # GET /transactions/
+client.transactions.retrieve(tx_id)                 # GET /transactions/{id}
+```
+
+### Withdrawals (saques PIX, somente produção)
+
+```ruby
+client.withdrawals.create(amount_cents:, pix_key:, pix_key_type:, idempotency_key: nil)  # POST /withdrawals/
+client.withdrawals.list(limit:, offset:, status:)                                        # GET  /withdrawals/
+client.withdrawals.retrieve(withdrawal_id)                                               # GET  /withdrawals/{id}
+```
+
+### Internal Transfers (transferências FluvPay para FluvPay, somente produção)
+
+```ruby
+client.internal_transfers.create(amount_cents:, recipient_email:, idempotency_key: nil)  # POST /internal-transfers/
+client.internal_transfers.list(direction:, limit:, offset:)                              # GET  /internal-transfers/
+client.internal_transfers.retrieve(transfer_id)                                          # GET  /internal-transfers/{id}
+```
+
+### Sandbox (somente com chave `fluv_test_`)
+
+```ruby
+client.sandbox.reset       # POST /test/reset
+client.sandbox.scenarios   # GET  /test/scenarios
+```
+
+### Campos de `charges.create`
+
+O método aceita exatamente os campos do contrato. Os campos `currency` e `method` não são aceitos: a API responde 422 quando enviados.
+
+| Campo | Tipo | Observação |
+|---|---|---|
+| `amount_cents` | Integer, obrigatório | 100 a 100000 (R$ 1,00 a R$ 1.000,00) |
+| `description` | String | até 500 caracteres |
+| `customer` | Hash | `{ name:, email:, document:, phone: }` |
+| `expires_in_seconds` | Integer | 60 a 604800 |
+| `affiliate_code` | String | 4 a 24 caracteres |
+| `split_rule_id` | String | 20 a 32 caracteres |
+| `pass_fee_to_payer` | Boolean | padrão `true` |
+| `metadata` | Hash | objeto livre |
+
+Os status possíveis de uma cobrança são `pending`, `paid`, `expired`, `cancelled` e `refunded`.
+
+## Paginação
+
+A API expõe dois formatos de envelope, ambos apresentados como objetos de página iteráveis:
+
+- `charges.list` e `transactions.list` expõem `page`, `per_page`, `total`, `has_next?` e `has_prev?`.
+- `withdrawals.list` e `internal_transfers.list` expõem `limit`, `offset` e `total`.
+
+```ruby
+page = client.withdrawals.list(limit: 10, offset: 0)
+puts [page.limit, page.offset, page.total].inspect
+page.each { |w| puts "#{w['id']} #{w['status']} #{w['net_cents']}" }
+```
+
+## Idempotência
+
+Os POSTs de escrita (`charges.create`, `withdrawals.create` e `internal_transfers.create`) enviam o header `Idempotency-Key`. Quando a chave não é informada, o SDK gera um UUIDv4. Reenviar a mesma chave devolve a resposta original. Reutilizar a chave com um payload diferente resulta em `FluvPay::ConflictError` com código `IDEMPOTENCY_CONFLICT`.
+
+```ruby
+chave = FluvPay::Client.new_idempotency_key
+client.charges.create(amount_cents: 5000, idempotency_key: chave)
+```
+
+## Webhooks
+
+A FluvPay assina cada entrega. O header `X-FluvPay-Signature` contém `v1=<hex>`, calculado da seguinte forma:
+
+```
+hex = HMAC_SHA256(secret, "{timestamp}." + corpo_cru)
+```
+
+O `secret` é o valor `whsec_...` exibido na criação do webhook, o `timestamp` vem do header `X-FluvPay-Timestamp` e `corpo_cru` é o corpo da requisição exatamente como recebido. A verificação exige o corpo cru, nunca o JSON re-serializado.
+
+```ruby
+begin
+  event = FluvPay::Webhooks.verify_signature(
+    raw_body,
+    request.headers["X-FluvPay-Signature"],
+    request.headers["X-FluvPay-Timestamp"],
+    "whsec_...",
+    tolerance_seconds: 300
+  )
+rescue FluvPay::SignatureVerificationError
+  halt 400, "assinatura inválida"
+end
+```
+
+Os eventos disponíveis são `charge.created`, `charge.paid`, `charge.expired`, `charge.cancelled`, `charge.refunded`, `payout.created`, `payout.completed` e `payout.failed`.
+
+## Erros
+
+Todos os erros herdam de `FluvPay::Error` e carregam `code`, `message`, `details`, `trace_id` e `status_code`.
+
+| Status | Exceção |
+|---|---|
+| 400 / 422 | `FluvPay::ValidationError` |
+| 401 | `FluvPay::AuthenticationError` |
+| 403 | `FluvPay::PermissionError` |
+| 404 | `FluvPay::NotFoundError` |
+| 409 | `FluvPay::ConflictError` |
+| 429 | `FluvPay::RateLimitError` (campo `retry_after`) |
+| 5xx | `FluvPay::ServerError` |
+| rede / timeout | `FluvPay::ConnectionError` |
+
+```ruby
+begin
+  client.charges.list
+rescue FluvPay::RateLimitError => err
+  puts "Rate limit. Tente novamente em #{err.retry_after} segundos."
+end
+```
+
+## Retentativas
+
+O SDK executa por padrão 2 retentativas com backoff exponencial e jitter. As retentativas ocorrem apenas em operações seguras: requisições GET e POSTs que carregam `Idempotency-Key`, e somente diante de respostas 429, 5xx ou falha de conexão. Em respostas 429, o header `Retry-After` é respeitado.
+
+```ruby
+client = FluvPay::Client.new(api_key: "fluv_live_...", max_retries: 4)   # aumentar
+client = FluvPay::Client.new(api_key: "fluv_live_...", max_retries: 0)   # desativar
+```
+
+## Desenvolvimento
+
+```bash
+bundle install
+rake test
+```
+
+Os testes unitários rodam sem acesso à rede, com `net/http` mockado via WebMock. O smoke test no sandbox roda somente quando a variável de ambiente `FLUVPAY_TEST_KEY` (prefixo `fluv_test_`) está presente; caso contrário, é pulado.
+
+## Licença
+
+MIT.

data/lib/fluvpay/client.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "openssl"
+require "securerandom"
+
+require_relative "version"
+require_relative "errors"
+require_relative "resources/charges"
+require_relative "resources/transactions"
+require_relative "resources/withdrawals"
+require_relative "resources/internal_transfers"
+require_relative "resources/sandbox"
+
+module FluvPay
+  # Cliente principal da FluvPay.
+  #
+  # Estilo Stripe: um objeto +FluvPay::Client+ configurado com a API key, expondo
+  # recursos (+charges+, +transactions+, +withdrawals+, +internal_transfers+ e
+  # +sandbox+). O transporte usa +net/http+ da biblioteca padrão, com retries
+  # (apenas em GET e POSTs idempotentes), geração automática de Idempotency-Key
+  # (UUIDv4) e mapeamento de erro tipado.
+  #
+  # @example
+  #   client = FluvPay::Client.new(api_key: "fluv_test_sua_chave")
+  #   charge = client.charges.create(amount_cents: 4990, description: "Pedido #1042")
+  #   puts charge["pix_copy_paste"]
+  class Client
+    DEFAULT_BASE_URL = "https://api.fluvpay.com/api/v1"
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_OPEN_TIMEOUT = 10
+    DEFAULT_MAX_RETRIES = 2
+    DEFAULT_BACKOFF_FACTOR = 0.5
+    DEFAULT_MAX_BACKOFF = 8.0
+
+    # @return [String] a API key configurada.
+    attr_reader :api_key
+    # @return [String] URL base sem barra final.
+    attr_reader :base_url
+    # @return [Integer] tentativas extras em 429/5xx/conexão.
+    attr_reader :max_retries
+
+    # Recursos expostos.
+    attr_reader :charges, :transactions, :withdrawals, :internal_transfers, :sandbox
+
+    # @param api_key [String] chave da API (+fluv_live_...+ ou +fluv_test_...+).
+    # @param base_url [String] URL base (padrão: produção e sandbox unificados).
+    # @param timeout [Numeric] timeout de leitura por requisição, em segundos.
+    # @param open_timeout [Numeric] timeout de abertura de conexão, em segundos.
+    # @param max_retries [Integer] tentativas extras (só GET e POSTs idempotentes).
+    # @param backoff_factor [Float] fator do backoff exponencial com jitter.
+    def initialize(api_key:, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT,
+                   open_timeout: DEFAULT_OPEN_TIMEOUT, max_retries: DEFAULT_MAX_RETRIES,
+                   backoff_factor: DEFAULT_BACKOFF_FACTOR)
+      if !api_key.is_a?(String) || api_key.empty?
+        raise ArgumentError, "api_key é obrigatória e deve ser uma string não vazia."
+      end
+
+      @api_key = api_key
+      @base_url = base_url.to_s.sub(%r{/+\z}, "")
+      @timeout = timeout
+      @open_timeout = open_timeout
+      @max_retries = max_retries
+      @backoff_factor = backoff_factor
+
+      @charges = Resources::Charges.new(self)
+      @transactions = Resources::Transactions.new(self)
+      @withdrawals = Resources::Withdrawals.new(self)
+      @internal_transfers = Resources::InternalTransfers.new(self)
+      @sandbox = Resources::Sandbox.new(self)
+    end
+
+    # @return [Boolean] true se a chave configurada for de sandbox (+fluv_test_+).
+    def test_mode?
+      self.class.test_key?(@api_key)
+    end
+
+    # @return [Boolean] true se a chave informada tiver prefixo +fluv_test_+.
+    def self.test_key?(api_key)
+      api_key.to_s.start_with?("fluv_test_")
+    end
+
+    # Gera um Idempotency-Key UUIDv4.
+    # @return [String]
+    def self.new_idempotency_key
+      SecureRandom.uuid
+    end
+
+    # Executa uma requisição e devolve o JSON já parseado (ou lança erro tipado).
+    #
+    # @param method [Symbol, String] verbo HTTP (:get, :post).
+    # @param path [String] caminho relativo à base_url (ex: "/charges/").
+    # @param params [Hash, nil] parâmetros de query (valores nil são removidos).
+    # @param body [Hash, nil] corpo JSON (valores nil são removidos no topo).
+    # @param idempotency_key [String, nil] valor do header Idempotency-Key.
+    # @param retry_request [Boolean, nil] força ou desliga o retry; nil = automático.
+    # @return [Object] JSON parseado da resposta.
+    def request(method, path, params: nil, body: nil, idempotency_key: nil, retry_request: nil)
+      upper = method.to_s.upcase
+      uri = build_uri(path, params)
+      headers = default_headers
+      headers["Idempotency-Key"] = idempotency_key unless idempotency_key.nil?
+
+      payload = nil
+      unless body.nil?
+        headers["Content-Type"] = "application/json"
+        payload = JSON.generate(clean_body(body))
+      end
+
+      retry_request = (upper == "GET" || (upper == "POST" && !idempotency_key.nil?)) if retry_request.nil?
+      max_attempts = retry_request ? (@max_retries + 1) : 1
+
+      attempt = 0
+      last_exception = nil
+      while attempt < max_attempts
+        begin
+          status, response, raw = perform(upper, uri, headers, payload)
+        rescue Net::OpenTimeout, Net::ReadTimeout => e
+          last_exception = e
+          if should_retry_connection?(retry_request, attempt, max_attempts)
+            sleep_backoff(attempt, nil)
+            attempt += 1
+            next
+          end
+          raise ConnectionError.new("Timeout ao conectar na FluvPay: #{e.message}")
+        rescue SocketError, SystemCallError, IOError, OpenSSL::SSL::SSLError => e
+          last_exception = e
+          if should_retry_connection?(retry_request, attempt, max_attempts)
+            sleep_backoff(attempt, nil)
+            attempt += 1
+            next
+          end
+          raise ConnectionError.new("Falha de conexão com a FluvPay: #{e.message}")
+        end
+
+        parsed = parse_json_body(raw)
+
+        return parsed if status < 300
+
+        if should_retry_status?(retry_request, status, attempt, max_attempts)
+          sleep_backoff(attempt, retry_after_seconds(response))
+          attempt += 1
+          next
+        end
+
+        raise Errors.from_response(
+          status,
+          parsed.is_a?(Hash) ? parsed : nil,
+          retry_after_header: header_value(response, "Retry-After")
+        )
+      end
+
+      if last_exception
+        raise ConnectionError.new(
+          "Falha de conexão com a FluvPay após #{max_attempts} tentativas: #{last_exception.message}"
+        )
+      end
+      raise ConnectionError.new("Falha de conexão com a FluvPay.")
+    end
+
+    private
+
+    def default_headers
+      {
+        "Authorization" => "Bearer #{@api_key}",
+        "User-Agent" => "fluvpay-ruby/#{FluvPay::VERSION}",
+        "Accept" => "application/json"
+      }
+    end
+
+    def build_uri(path, params)
+      uri = URI.parse("#{@base_url}#{path}")
+      cleaned = clean_params(params)
+      uri.query = URI.encode_www_form(cleaned) if cleaned && !cleaned.empty?
+      uri
+    end
+
+    def clean_params(params)
+      return nil if params.nil?
+
+      params.reject { |_, v| v.nil? }.transform_keys(&:to_s)
+    end
+
+    def clean_body(body)
+      return body unless body.is_a?(Hash)
+
+      body.reject { |_, v| v.nil? }
+    end
+
+    # Executa uma única chamada HTTP. Retorna [status, objeto_response, corpo_cru].
+    def perform(method, uri, headers, payload)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = @open_timeout
+      http.read_timeout = @timeout
+
+      request_class =
+        case method
+        when "GET" then Net::HTTP::Get
+        when "POST" then Net::HTTP::Post
+        else raise ArgumentError, "Método HTTP não suportado: #{method}"
+        end
+
+      req = request_class.new(uri.request_uri)
+      headers.each { |k, v| req[k] = v }
+      req.body = payload if payload
+
+      response = http.request(req)
+      [response.code.to_i, response, response.body]
+    end
+
+    def parse_json_body(raw)
+      return nil if raw.nil? || raw.to_s.empty?
+
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def header_value(response, name)
+      return nil unless response.respond_to?(:[])
+
+      response[name]
+    end
+
+    def should_retry_connection?(retry_request, attempt, max_attempts)
+      retry_request && attempt < max_attempts - 1
+    end
+
+    def should_retry_status?(retry_request, status, attempt, max_attempts)
+      return false unless retry_request
+      return false if attempt >= max_attempts - 1
+
+      status == 429 || status >= 500
+    end
+
+    def retry_after_seconds(response)
+      raw = header_value(response, "Retry-After")
+      return nil if raw.nil?
+
+      Float(raw)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def sleep_backoff(attempt, retry_after)
+      delay =
+        if !retry_after.nil? && retry_after >= 0
+          retry_after
+        else
+          base = @backoff_factor * (2**attempt)
+          jitter = rand * @backoff_factor
+          [base + jitter, DEFAULT_MAX_BACKOFF].min
+        end
+      sleep(delay) if delay.positive?
+    end
+  end
+end

data/lib/fluvpay/errors.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module FluvPay
+  # Exceção base de todos os erros do SDK.
+  #
+  # Carrega os campos do envelope de erro da API
+  # (+{ "error": { code, message, details, trace_id } }+) além do status HTTP.
+  # Toda exceção tipada do SDK herda desta classe, então um único
+  # +rescue FluvPay::Error+ captura qualquer falha conhecida.
+  class Error < StandardError
+    # @return [String, nil] código canônico do erro (ex: "VALIDATION_ERROR").
+    attr_reader :code
+    # @return [Array<Hash>] lista de detalhes do erro (cada item com field/message/type).
+    attr_reader :details
+    # @return [String, nil] identificador da requisição para correlacionar nos logs.
+    attr_reader :trace_id
+    # @return [Integer, nil] status HTTP que originou o erro.
+    attr_reader :status_code
+
+    def initialize(message = nil, code: nil, details: nil, trace_id: nil, status_code: nil)
+      super(message)
+      @code = code
+      @details = details || []
+      @trace_id = trace_id
+      @status_code = status_code
+    end
+  end
+
+  # 400/422: payload ou parâmetros inválidos (VALIDATION_ERROR) ou estado
+  # impeditivo (ex: INSUFFICIENT_BALANCE). Inspecione +#details+ para os campos.
+  class ValidationError < Error; end
+
+  # 401: autenticação ausente ou inválida (AUTHENTICATION_REQUIRED).
+  class AuthenticationError < Error; end
+
+  # 403: escopo insuficiente ou operação não permitida para a conta/ambiente
+  # (PERMISSION_DENIED, API_KEY_INSUFFICIENT_SCOPE, SANDBOX_NOT_SUPPORTED_*).
+  class PermissionError < Error; end
+
+  # 404: recurso não encontrado (NOT_FOUND).
+  class NotFoundError < Error; end
+
+  # 409: conflito de idempotência (IDEMPOTENCY_CONFLICT), quando a mesma
+  # Idempotency-Key é reutilizada com um payload diferente.
+  class ConflictError < Error; end
+
+  # 429: limite de requisições excedido (RATE_LIMITED).
+  # +#retry_after+ traz os segundos sugeridos no header +Retry-After+.
+  class RateLimitError < Error
+    # @return [Float, nil] segundos a aguardar antes de tentar de novo.
+    attr_reader :retry_after
+
+    def initialize(message = nil, retry_after: nil, **kwargs)
+      super(message, **kwargs)
+      @retry_after = retry_after
+    end
+  end
+
+  # 5xx: erro interno da FluvPay (SERVER_ERROR e afins).
+  class ServerError < Error; end
+
+  # Falha de rede, timeout ou conexão recusada antes de obter uma resposta HTTP.
+  class ConnectionError < Error; end
+
+  # A assinatura de um webhook não confere, está ausente, mal formatada ou
+  # fora da tolerância de tempo. Lançada por {FluvPay::Webhooks.verify_signature}.
+  class SignatureVerificationError < Error; end
+
+  module Errors
+    # Converte uma resposta de erro (status + corpo já parseado) na exceção
+    # tipada correspondente. Usado internamente pelo cliente HTTP.
+    #
+    # @param status_code [Integer] status HTTP da resposta.
+    # @param body [Hash, nil] corpo JSON já parseado (espera-se a chave "error").
+    # @param retry_after_header [String, nil] valor cru do header Retry-After.
+    # @return [FluvPay::Error] a exceção pronta para ser lançada.
+    def self.from_response(status_code, body, retry_after_header: nil)
+      error_body = body.is_a?(Hash) ? (body["error"] || body[:error]) : nil
+      error_body = {} unless error_body.is_a?(Hash)
+
+      code = error_body["code"] || error_body[:code]
+      message = error_body["message"] || error_body[:message] || default_message(status_code)
+      details = error_body["details"] || error_body[:details] || []
+      trace_id = error_body["trace_id"] || error_body[:trace_id]
+
+      kwargs = { code: code, details: details, trace_id: trace_id, status_code: status_code }
+
+      case status_code
+      when 400, 422
+        ValidationError.new(message, **kwargs)
+      when 401
+        AuthenticationError.new(message, **kwargs)
+      when 403
+        PermissionError.new(message, **kwargs)
+      when 404
+        NotFoundError.new(message, **kwargs)
+      when 409
+        ConflictError.new(message, **kwargs)
+      when 429
+        RateLimitError.new(message, retry_after: parse_retry_after(retry_after_header), **kwargs)
+      else
+        if status_code >= 500
+          ServerError.new(message, **kwargs)
+        else
+          Error.new(message, **kwargs)
+        end
+      end
+    end
+
+    def self.parse_retry_after(raw)
+      return nil if raw.nil?
+
+      Float(raw)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def self.default_message(status_code)
+      "A FluvPay retornou o status HTTP #{status_code}."
+    end
+
+    private_class_method :parse_retry_after, :default_message
+  end
+end

data/lib/fluvpay/resources/charges.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "list_objects"
+require "erb"
+
+module FluvPay
+  module Resources
+    # Recurso de cobranças PIX: criar, recuperar e listar.
+    class Charges
+      def initialize(client)
+        @client = client
+      end
+
+      # Cria uma cobrança PIX.
+      #
+      # Escopo exigido: +payments.create+. O header +Idempotency-Key+ é
+      # obrigatório na API; se não for informado, o SDK gera um UUIDv4
+      # automaticamente.
+      #
+      # @param amount_cents [Integer] valor em centavos (100..100000), obrigatório.
+      # @param description [String, nil] descrição (até 500 caracteres).
+      # @param customer [Hash, nil] dados do pagador (name, email, document, phone).
+      # @param expires_in_seconds [Integer, nil] expiração em segundos (60..604800).
+      # @param affiliate_code [String, nil] código de afiliado (4..24 caracteres).
+      # @param split_rule_id [String, nil] id de regra de split (20..32 caracteres).
+      # @param pass_fee_to_payer [Boolean, nil] repassar a taxa ao pagador (default true).
+      # @param metadata [Hash, nil] objeto livre de metadados.
+      # @param idempotency_key [String, nil] Idempotency-Key; gerado se omitido.
+      # @return [Hash] a cobrança criada.
+      def create(amount_cents:, description: nil, customer: nil, expires_in_seconds: nil,
+                 affiliate_code: nil, split_rule_id: nil, pass_fee_to_payer: nil,
+                 metadata: nil, idempotency_key: nil)
+        body = {
+          "amount_cents" => amount_cents,
+          "description" => description,
+          "customer" => clean_customer(customer),
+          "expires_in_seconds" => expires_in_seconds,
+          "affiliate_code" => affiliate_code,
+          "split_rule_id" => split_rule_id,
+          "pass_fee_to_payer" => pass_fee_to_payer,
+          "metadata" => metadata
+        }
+        key = idempotency_key || FluvPay::Client.new_idempotency_key
+        @client.request(:post, "/charges/", body: body, idempotency_key: key)
+      end
+
+      # Recupera uma cobrança por ID.
+      #
+      # Escopo exigido: +payments.read+.
+      # @param charge_id [String] identificador da cobrança.
+      # @return [Hash] a cobrança.
+      def retrieve(charge_id)
+        @client.request(:get, "/charges/#{escape(charge_id)}")
+      end
+
+      # Lista cobranças.
+      #
+      # Escopo exigido: +payments.read+. Envelope: +page+/+per_page+.
+      # @param status [String, nil] filtra por status.
+      # @param page [Integer, nil] página (1-based).
+      # @param per_page [Integer, nil] itens por página (máx 100).
+      # @param sort [String, nil] campo de ordenação (ex: "-created_at").
+      # @return [FluvPay::Resources::PageList] página com +.data+ e metadados.
+      def list(status: nil, page: nil, per_page: nil, sort: nil)
+        params = {
+          "status" => status,
+          "page" => page,
+          "per_page" => per_page,
+          "sort" => sort
+        }
+        payload = @client.request(:get, "/charges/", params: params)
+        PageList.new(payload)
+      end
+
+      private
+
+      def clean_customer(customer)
+        return nil if customer.nil?
+
+        customer.reject { |_, v| v.nil? }.transform_keys(&:to_s)
+      end
+
+      def escape(value)
+        ERB::Util.url_encode(value.to_s)
+      end
+    end
+  end
+end

data/lib/fluvpay/resources/internal_transfers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "list_objects"
+require "erb"
+
+module FluvPay
+  module Resources
+    # Recurso de transferências internas (conta FluvPay para conta FluvPay).
+    class InternalTransfers
+      def initialize(client)
+        @client = client
+      end
+
+      # Cria uma transferência interna FluvPay para FluvPay.
+      #
+      # Escopo exigido: +withdrawals.create+. Idempotency-Key gerado se omitido.
+      # Não suportado em sandbox: chaves +fluv_test_+ recebem 403
+      # (SANDBOX_NOT_SUPPORTED_FOR_TRANSFERS). Informe exatamente um entre
+      # +recipient_email+ e +recipient_merchant_id+.
+      #
+      # @param amount_cents [Integer] valor em centavos (100..10000000).
+      # @param recipient_email [String, nil] email do destinatário.
+      # @param recipient_merchant_id [String, nil] ULID do merchant destinatário (26 chars).
+      # @param description [String, nil] descrição (até 140 caracteres).
+      # @param idempotency_key [String, nil] Idempotency-Key; gerado se omitido.
+      # @return [Hash] a transferência criada.
+      def create(amount_cents:, recipient_email: nil, recipient_merchant_id: nil,
+                 description: nil, idempotency_key: nil)
+        body = {
+          "amount_cents" => amount_cents,
+          "recipient_email" => recipient_email,
+          "recipient_merchant_id" => recipient_merchant_id,
+          "description" => description
+        }
+        key = idempotency_key || FluvPay::Client.new_idempotency_key
+        @client.request(:post, "/internal-transfers/", body: body, idempotency_key: key)
+      end
+
+      # Lista transferências internas.
+      #
+      # Escopo exigido: +transfers.read+. Envelope: +limit+/+offset+.
+      # @param direction [String, nil] "sent" (enviadas) ou "received" (recebidas).
+      # @param limit [Integer, nil] itens por página (1..100).
+      # @param offset [Integer, nil] deslocamento (>= 0).
+      # @return [FluvPay::Resources::OffsetList] página com +.data+ e metadados.
+      def list(direction: nil, limit: nil, offset: nil)
+        params = {
+          "direction" => direction,
+          "limit" => limit,
+          "offset" => offset
+        }
+        payload = @client.request(:get, "/internal-transfers/", params: params)
+        OffsetList.new(payload)
+      end
+
+      # Recupera uma transferência interna por ID.
+      #
+      # @param transfer_id [String] identificador da transferência.
+      # @return [Hash] a transferência.
+      def retrieve(transfer_id)
+        @client.request(:get, "/internal-transfers/#{ERB::Util.url_encode(transfer_id.to_s)}")
+      end
+    end
+  end
+end

data/lib/fluvpay/resources/list_objects.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module FluvPay
+  module Resources
+    # Página baseada em +page+/+per_page+ (usada por charges.list e transactions.list).
+    #
+    # Expõe +#data+ (os itens) e os metadados +page+, +per_page+, +total+,
+    # +has_next+ e +has_prev+, exatamente como o backend retorna. Também é
+    # iterável: +page.each { |item| ... }+.
+    class PageList
+      include Enumerable
+
+      # @return [Array<Hash>] itens da página.
+      attr_reader :data
+      attr_reader :page, :per_page, :total
+
+      def initialize(payload)
+        payload ||= {}
+        @data = payload["data"] || []
+        @page = payload["page"]
+        @per_page = payload["per_page"]
+        @total = payload["total"]
+        @has_next = payload["has_next"]
+        @has_prev = payload["has_prev"]
+      end
+
+      # @return [Boolean] true se existe próxima página.
+      def has_next?
+        @has_next ? true : false
+      end
+
+      # @return [Boolean] true se existe página anterior.
+      def has_prev?
+        @has_prev ? true : false
+      end
+
+      def each(&block)
+        @data.each(&block)
+      end
+    end
+
+    # Página baseada em +limit+/+offset+ (usada por withdrawals.list e
+    # internal_transfers.list). Expõe +#data+ e os metadados +limit+, +offset+
+    # e +total+, exatamente como o backend retorna. Também é iterável.
+    class OffsetList
+      include Enumerable
+
+      # @return [Array<Hash>] itens da página.
+      attr_reader :data
+      attr_reader :limit, :offset, :total
+
+      def initialize(payload)
+        payload ||= {}
+        @data = payload["data"] || []
+        @limit = payload["limit"]
+        @offset = payload["offset"]
+        @total = payload["total"]
+      end
+
+      def each(&block)
+        @data.each(&block)
+      end
+    end
+  end
+end

data/lib/fluvpay/resources/sandbox.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module FluvPay
+  module Resources
+    # Utilitários de teste, disponíveis apenas com chave +fluv_test_+.
+    class Sandbox
+      def initialize(client)
+        @client = client
+      end
+
+      # Apaga todos os dados do sandbox (só chave de teste).
+      #
+      # @return [Hash] resultado com +reset+, +deleted_charges+ e +merchant_id+.
+      def reset
+        @client.request(:post, "/test/reset")
+      end
+
+      # Lista os valores mágicos do sandbox.
+      #
+      # @return [Hash] com +info+ e a lista +scenarios+.
+      def scenarios
+        @client.request(:get, "/test/scenarios")
+      end
+    end
+  end
+end

data/lib/fluvpay/resources/transactions.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "list_objects"
+require "erb"
+
+module FluvPay
+  module Resources
+    # Recurso de extrato financeiro consolidado (entradas e saídas).
+    class Transactions
+      def initialize(client)
+        @client = client
+      end
+
+      # Lista lançamentos do extrato.
+      #
+      # Escopos exigidos (qualquer um): +payments.read+, +transfers.read+ ou
+      # +withdrawals.read+. Envelope: +page+/+per_page+.
+      # Não suportado em sandbox: chaves +fluv_test_+ recebem 403.
+      #
+      # @param page [Integer, nil] página (1-based).
+      # @param per_page [Integer, nil] itens por página (máx 100).
+      # @param sort [String, nil] campo de ordenação (ex: "-created_at").
+      # @return [FluvPay::Resources::PageList] página com +.data+ e metadados.
+      def list(page: nil, per_page: nil, sort: nil)
+        params = {
+          "page" => page,
+          "per_page" => per_page,
+          "sort" => sort
+        }
+        payload = @client.request(:get, "/transactions/", params: params)
+        PageList.new(payload)
+      end
+
+      # Recupera um lançamento por ID.
+      #
+      # @param tx_id [String] identificador do lançamento.
+      # @return [Hash] o lançamento.
+      def retrieve(tx_id)
+        @client.request(:get, "/transactions/#{ERB::Util.url_encode(tx_id.to_s)}")
+      end
+    end
+  end
+end

data/lib/fluvpay/resources/withdrawals.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "list_objects"
+require "erb"
+
+module FluvPay
+  module Resources
+    # Recurso de saques PIX da conta para uma chave PIX.
+    class Withdrawals
+      def initialize(client)
+        @client = client
+      end
+
+      # Cria um saque PIX.
+      #
+      # Escopo exigido: +withdrawals.create+. Idempotency-Key gerado se omitido.
+      # Não suportado em sandbox: chaves +fluv_test_+ recebem 403
+      # (SANDBOX_NOT_SUPPORTED_FOR_WITHDRAWALS).
+      #
+      # @param amount_cents [Integer] valor bruto em centavos (100..10000000).
+      # @param pix_key [String] chave PIX de destino (1..140 caracteres).
+      # @param pix_key_type [String] tipo da chave: cpf, cnpj, email, phone ou evp.
+      # @param description [String, nil] descrição (até 140 caracteres).
+      # @param idempotency_key [String, nil] Idempotency-Key; gerado se omitido.
+      # @return [Hash] o saque criado.
+      def create(amount_cents:, pix_key:, pix_key_type:, description: nil, idempotency_key: nil)
+        body = {
+          "amount_cents" => amount_cents,
+          "pix_key" => pix_key,
+          "pix_key_type" => pix_key_type,
+          "description" => description
+        }
+        key = idempotency_key || FluvPay::Client.new_idempotency_key
+        @client.request(:post, "/withdrawals/", body: body, idempotency_key: key)
+      end
+
+      # Lista saques.
+      #
+      # Escopo exigido: +withdrawals.read+. Envelope: +limit+/+offset+.
+      # @param limit [Integer, nil] itens por página (1..100).
+      # @param offset [Integer, nil] deslocamento (>= 0).
+      # @param status [String, nil] filtra por status.
+      # @return [FluvPay::Resources::OffsetList] página com +.data+ e metadados.
+      def list(limit: nil, offset: nil, status: nil)
+        params = {
+          "limit" => limit,
+          "offset" => offset,
+          "status" => status
+        }
+        payload = @client.request(:get, "/withdrawals/", params: params)
+        OffsetList.new(payload)
+      end
+
+      # Recupera um saque por ID.
+      #
+      # @param withdrawal_id [String] identificador do saque.
+      # @return [Hash] o saque.
+      def retrieve(withdrawal_id)
+        @client.request(:get, "/withdrawals/#{ERB::Util.url_encode(withdrawal_id.to_s)}")
+      end
+    end
+  end
+end

data/lib/fluvpay/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FluvPay
+  # Versão atual da gem. Acompanha o cabeçalho User-Agent enviado em cada requisição.
+  VERSION = "1.0.0"
+end

data/lib/fluvpay/webhooks.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+
+module FluvPay
+  # Verificação de assinatura de webhooks da FluvPay.
+  #
+  # A FluvPay assina cada entrega com HMAC-SHA256 sobre +"{timestamp}." + corpo_cru+,
+  # usando o segredo +whsec_...+ do webhook. O header +X-FluvPay-Signature+ traz
+  # +v1=<hex>+. A verificação usa comparação em tempo constante e exige o corpo CRU
+  # (a string exatamente como recebida), nunca reserializado.
+  module Webhooks
+    EVENT_HEADER = "X-FluvPay-Event"
+    TIMESTAMP_HEADER = "X-FluvPay-Timestamp"
+    DELIVERY_ID_HEADER = "X-FluvPay-Delivery-Id"
+    SIGNATURE_HEADER = "X-FluvPay-Signature"
+
+    # Eventos disponíveis (8). Espelha o catálogo do contrato OpenAPI.
+    EVENT_TYPES = %w[
+      charge.created
+      charge.paid
+      charge.expired
+      charge.cancelled
+      charge.refunded
+      payout.created
+      payout.completed
+      payout.failed
+    ].freeze
+
+    # Evento de webhook já verificado e parseado, devolvido por
+    # {FluvPay::Webhooks.verify_signature}.
+    class Event
+      # @return [String, nil] tipo do evento (ex: "charge.paid").
+      attr_reader :type
+      # @return [String, nil] identificador da entrega (X-FluvPay-Delivery-Id).
+      attr_reader :delivery_id
+      # @return [String] timestamp cru recebido (X-FluvPay-Timestamp).
+      attr_reader :timestamp
+      # @return [Hash] objeto "data" do evento (ou o payload inteiro como fallback).
+      attr_reader :data
+      # @return [Hash] payload completo parseado.
+      attr_reader :raw
+
+      def initialize(type:, delivery_id:, timestamp:, data:, raw:)
+        @type = type
+        @delivery_id = delivery_id
+        @timestamp = timestamp
+        @data = data
+        @raw = raw
+      end
+    end
+
+    module_function
+
+    # Recalcula o hex da assinatura: HMAC_SHA256(secret, timestamp + "." + corpo_cru).
+    #
+    # @param secret [String] segredo do webhook (+whsec_...+).
+    # @param timestamp [String] valor de +X-FluvPay-Timestamp+.
+    # @param raw_body [String] corpo CRU da requisição.
+    # @return [String] assinatura em hexadecimal.
+    def compute_signature(secret, timestamp, raw_body)
+      signed_payload = "#{timestamp}.#{raw_body}"
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("SHA256"), secret.to_s, signed_payload)
+    end
+
+    # Verifica a assinatura de um webhook e devolve o evento parseado.
+    #
+    # @param payload [String] corpo CRU da requisição, exatamente como recebido.
+    # @param signature_header [String] valor de +X-FluvPay-Signature+ (formato +v1=<hex>+).
+    # @param timestamp [String] valor de +X-FluvPay-Timestamp+.
+    # @param secret [String] segredo do webhook (+whsec_...+).
+    # @param tolerance_seconds [Integer, nil] se informado e o timestamp for numérico,
+    #   rejeita entregas mais antigas que esse limite (proteção contra replay).
+    # @param event_type [String, nil] valor de +X-FluvPay-Event+ (preenche Event#type).
+    # @param delivery_id [String, nil] valor de +X-FluvPay-Delivery-Id+.
+    # @return [FluvPay::Webhooks::Event] evento verificado.
+    # @raise [FluvPay::SignatureVerificationError] assinatura ausente, inválida ou
+    #   fora da tolerância de tempo.
+    def verify_signature(payload, signature_header, timestamp, secret,
+                         tolerance_seconds: nil, event_type: nil, delivery_id: nil)
+      provided = extract_v1(signature_header.to_s)
+      if provided.nil? || provided.empty?
+        raise SignatureVerificationError.new(
+          "Assinatura ausente ou em formato inválido (esperado 'v1=<hex>')."
+        )
+      end
+
+      check_tolerance!(timestamp, tolerance_seconds) unless tolerance_seconds.nil?
+
+      expected = compute_signature(secret, timestamp, payload)
+      unless secure_compare(expected, provided)
+        raise SignatureVerificationError.new("Assinatura do webhook não confere.")
+      end
+
+      parsed = parse_json(payload)
+      resolved_type = event_type || (parsed.is_a?(Hash) ? parsed["event"] : nil)
+      data =
+        if parsed.is_a?(Hash) && parsed["data"].is_a?(Hash)
+          parsed["data"]
+        elsif parsed.is_a?(Hash)
+          parsed
+        else
+          {}
+        end
+
+      Event.new(
+        type: resolved_type,
+        delivery_id: delivery_id,
+        timestamp: timestamp,
+        data: data,
+        raw: parsed.is_a?(Hash) ? parsed : {}
+      )
+    end
+
+    # Extrai o hex após +v1=+ (aceita vários esquemas separados por vírgula).
+    def extract_v1(signature_header)
+      return nil if signature_header.nil? || signature_header.empty?
+
+      signature_header.split(",").each do |part|
+        item = part.strip
+        return item[3..].to_s.strip if item.start_with?("v1=")
+      end
+      nil
+    end
+
+    # Rejeita entregas fora da janela de tolerância (proteção contra replay).
+    def check_tolerance!(timestamp, tolerance_seconds)
+      ts_int =
+        begin
+          Integer(timestamp.to_s, 10)
+        rescue ArgumentError, TypeError
+          raise SignatureVerificationError.new(
+            "Timestamp não numérico: impossível validar a tolerância de tempo."
+          )
+        end
+
+      age = (Time.now.to_i - ts_int).abs
+      return unless age > tolerance_seconds
+
+      raise SignatureVerificationError.new(
+        "Timestamp fora da tolerância (#{age}s > #{tolerance_seconds}s); possível replay."
+      )
+    end
+
+    # Comparação de strings em tempo constante, resistente a timing attacks.
+    def secure_compare(expected, provided)
+      a = expected.to_s.b
+      b = provided.to_s.b
+      return false unless a.bytesize == b.bytesize
+
+      OpenSSL.fixed_length_secure_compare(a, b)
+    rescue StandardError
+      # Fallback puro Ruby caso fixed_length_secure_compare não esteja disponível.
+      bytes = a.unpack("C*")
+      res = 0
+      b.unpack("C*").each_with_index { |byte, i| res |= byte ^ bytes[i] }
+      res.zero?
+    end
+
+    def parse_json(payload)
+      text = payload.is_a?(String) ? payload : payload.to_s
+      JSON.parse(text)
+    rescue JSON::ParserError, TypeError
+      {}
+    end
+
+    private_class_method :parse_json, :check_tolerance!
+  end
+end

data/lib/fluvpay.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# FluvPay: SDK oficial em Ruby para a API de pagamentos PIX da FluvPay.
+#
+# Cobranças, saques, transferências internas, sandbox e verificação de
+# webhooks por uma interface idiomática e previsível, construída apenas sobre
+# a biblioteca padrão (net/http e json).
+#
+# @example Criar uma cobrança
+#   require "fluvpay"
+#
+#   client = FluvPay::Client.new(api_key: "fluv_test_sua_chave")
+#   charge = client.charges.create(amount_cents: 4990, description: "Pedido #1042")
+#   puts charge["pix_copy_paste"]
+module FluvPay
+end
+
+require_relative "fluvpay/version"
+require_relative "fluvpay/errors"
+require_relative "fluvpay/webhooks"
+require_relative "fluvpay/client"

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: fluvpay
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- FluvPay
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.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: webmock
+  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'
+description: 'Cliente idiomático da FluvPay: cobranças PIX, saques, transferências
+  internas, sandbox e verificação de webhooks. Idempotência automática, retries seguros
+  e erros tipados, usando apenas a biblioteca padrão (net/http).'
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fluvpay.rb
+- lib/fluvpay/client.rb
+- lib/fluvpay/errors.rb
+- lib/fluvpay/resources/charges.rb
+- lib/fluvpay/resources/internal_transfers.rb
+- lib/fluvpay/resources/list_objects.rb
+- lib/fluvpay/resources/sandbox.rb
+- lib/fluvpay/resources/transactions.rb
+- lib/fluvpay/resources/withdrawals.rb
+- lib/fluvpay/version.rb
+- lib/fluvpay/webhooks.rb
+homepage: https://docs.fluvpay.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://fluvpay.com
+  documentation_uri: https://docs.fluvpay.com
+  source_code_uri: https://github.com/fluvpay/fluvpay-ruby
+  changelog_uri: https://github.com/fluvpay/fluvpay-ruby/releases
+  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: SDK oficial em Ruby para a API de pagamentos PIX da FluvPay.
+test_files: []