lunixi-sdk 0.1.2 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dda2f615f12541201a6f330dbbdc4329f467a33ac7e5aea8aec2d4db0794fe88
-  data.tar.gz: c5c9c52a55000090157e7afcdd1fbefc3e96dd79112b65adc581c7e6664e2a4b
+  metadata.gz: 40366427b51fa84757c9c338364d43e025105e683a04790919a4707d300418ec
+  data.tar.gz: 703ff10b22fdd261e095f129ac5c9c7e25b643843cf2cbeabc3b88075ac5b79f
 SHA512:
-  metadata.gz: 25e95b8ed3a4b7f22e745cc83b5b1c21a73faa669dddc11bdfd1c92cd69d656ebff7f402c75e1462b0c00b13cca25c71a7f51fd57c397edb019f53e00f0df06b
-  data.tar.gz: 7b888abc11c519dd5144dcc7b83f05fd37db37bb50e8907a7ff737db382f177a1cc26d4da311fa1eeaae59ab037604eb6b50e01700329291d9c46ad855bc1581
+  metadata.gz: bcfe1c791b4270392c9ce4f7c13d0592c9f2923ede5ad9be524ac7df8e487d3dd69d4468c17de7e33c11a7d8e243618da9a8e5c74dfb046b824140dda3991985
+  data.tar.gz: a10f6eaadfeae29b023b67fd5293d3d65979ed35019a20ef467c794a481dc6e5d850fd772b2a30788580367b78007a78c73d2c2be9f87212c9e92684706cb8ae

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.0.1 — 2026-11-01
+
+- Align Rails sample API mocks and expectations with canonical minor-unit strings while preserving numeric-input rejection tests; runtime admission is unchanged.
+- Preserve response parsing limits and error handling in a private helper; close RuboCop findings without suppressions.
+- Update 1.0.1 installation and exact-tag publishing guidance.
+
+## 1.0.0 — 2026-11-01
+
+- Reject explicit null capture/refund amounts; full remaining operations use omission or the dedicated API described in MIGRATION-1.0.md.
+
+- Breaking: public money request/response fields require canonical minor-unit strings; JSON numbers are rejected.
+- Exact signed 64-bit fiat arithmetic and currency-aware decimal text conversion preserve values above JavaScript’s safe-integer limit.
+- See [MIGRATION-1.0.md](MIGRATION-1.0.md) before upgrading.
+
+
 ## 0.1.2 — 2026-10-31
 
 - Add strict backend payment-page URL and official embedded-form configuration helpers, without rebuilding hosted URLs from tokens.

data/MIGRATION-1.0.md

@@ -0,0 +1,19 @@
+# 1.0.0 migration
+
+All public monetary request and response fields now use canonical base-10 **strings in minor units**. For example, `amount: "1990"` represents TRY 19.90. This includes basket `price`, split and note amounts, capture/refund, balances and fixed fees on supported endpoints. Numeric JSON money is rejected; convert trusted native exact integers explicitly at your application boundary. Rates, basis points, quantities, counts and timestamps remain numeric.
+
+Use the package’s decimal-text conversion helper with the actual currency. JPY has exponent 0, TRY/USD 2, KWD 3. Do not parse decimal text through float/double or assume a factor of 100. `"9007199254740993"` remains exact. Fiat amounts must fit signed 64-bit storage (maximum `"9223372036854775807"`); provider/platform limits may be lower. Crypto is a separate domain.
+
+Canonical strings reject whitespace, signs on nonnegative values, leading zeros, decimals, exponents, `NaN`, `Infinity`, and negative zero. Payments are positive. Settlement totals may be zero; balances may be signed. Only omission retains remaining-amount semantics. Explicit JSON `null` and `"0"` are invalid. Split-refund amount remains required where the existing API requires it.
+
+Update call sites, persisted outbound request schemas and gateway response fixtures together. Preserve an existing attempt’s exact body, idempotency key, environment and credential profile; reconcile historical attempts before creating new ones. The SDK does not silently rewrite historical payment bytes or accept both numeric and string wire money. Native internal exact integer storage may remain unchanged.
+
+Raw webhook verification, signatures, authentication and replay/idempotency protections are unchanged. Upgrade the gateway and integrations as one coordinated breaking cut. Install version 1.0.0 after it is available in this package’s distribution channel.
+
+Use `payments.create_intent({ amount: '1990', ... }, idempotency_key: key)` and `Lunixi::Money.decimal_to_minor('19.90', 'TRY')`. Capture/refund accept strings or omitted keywords; numeric money raises `ConfigurationError`.
+
+## Optional capture/refund amounts
+
+Omit the `amount:` keyword for the remaining balance: `payments.capture(id, idempotency_key: key)` and `payments.refund(id, idempotency_key: key, reason: reason)`. Explicit `amount: nil` is rejected. The omission marker is private and never serialized.
+
+The advanced/raw request boundary also rejects a present `amount: null` on capture/refund routes. Unrelated nullable response fields and merchant metadata keep their existing meaning.

data/README.md

@@ -2,24 +2,25 @@
 
 # Lunixi Ruby SDK
 
+**Version 1.0.1 uses canonical minor-unit strings for money.** This is a breaking change from 0.x; update request and response handling together. See [migration](MIGRATION-1.0.md).
+
 [English](README.md) · [Türkçe](README.tr.md) · [Documentation](https://docs.lunixi.com/sdks/ruby) · [Rails sample](samples/rails)
 
-Server-side Ruby client for Lunixi payments, fraud and signed gateway requests. It signs requests with OpenSSL Ed25519, caches tokens across threads, preserves integer minor-unit amounts, retries safe operations with the same idempotency key, and verifies raw-body v2 webhooks. Private keys and card details stay out of the browser and application logs.
+Server-side Ruby client for Lunixi payments, fraud and signed gateway requests. It signs requests with OpenSSL Ed25519, caches tokens across threads, preserves canonical minor-unit strings, retries safe operations with the same idempotency key, and verifies raw-body v2 webhooks. Private keys and card details stay out of the browser and application logs.
 
 ## Requirements and installation
 
 Ruby **3.3+**, OpenSSL with **Ed25519** support, and Bundler. The runnable Rails sample uses **Rails 8.1** and SQLite. The core gem does not depend on Rails.
 
-Version **0.1.2** is distributed as source here. RubyGems publication is a separate release step; this guide does not assume a published registry package.
+After version 1.0.1 is available on RubyGems, add the dependency and run `bundle install`:
 
-```bash
-git clone https://github.com/Lunixi-Payment/lunixi-ruby.git
-cd lunixi-ruby
-bundle install
-gem build lunixi-sdk.gemspec
-gem install ./lunixi-sdk-0.1.2.gem
+```ruby
+source 'https://rubygems.org'
+gem 'lunixi-sdk', '1.0.1'
 ```
 
+Keep `Gemfile.lock` to retain the reviewed dependency resolution.
+
 Inside this checkout, `bundle exec ruby …` loads the local gem. An application can use a reviewed checkout with `gem 'lunixi-sdk', path: '/absolute/path/to/lunixi-ruby'`. Pin an audited commit when using a Bundler Git source. Never use an unpinned moving branch for a production deployment.
 
 ## Create a client
@@ -55,11 +56,11 @@ Calculate the total on the server and persist a UUID idempotency key with the pa
 ```ruby
 result = lunixi.payments.create_intent(
   {
-    amount: 10_050, # 100.50 TRY; integer kuruş, never 100.50
+    amount: "10050", # 100.50 TRY; integer kuruş, never 100.50
     currency: 'TRY',
     orderId: order.public_id,
     callbackUrl: 'https://merchant.example/payments/return',
-    basketItems: [{ id: 'item-1', name: 'Product', itemType: 'PHYSICAL', price: 10_050 }]
+    basketItems: [{ id: 'item-1', name: 'Product', itemType: 'PHYSICAL', price: "10050" }]
   },
   idempotency_key: order.persisted_payment_attempt_key
 )
@@ -67,7 +68,6 @@ result = lunixi.payments.create_intent(
 intent_id = result.fetch('data').fetch('paymentId')
 checkout_token = result.fetch('data').fetch('token')
 # Persist the intent id and encrypt the checkout token at rest.
-# The Rails sample validates the token and builds a fixed-origin redirect:
 # Optional hosted checkout uses the validated backend paymentPageUrl, never a URL built from this token.
 ```
 
@@ -82,8 +82,8 @@ The shared Lunixi form owns enabled payment methods and supports the methods con
 | Create intent | `payments.create_intent(body, idempotency_key:)` |
 | Get/list payment | `payments.get(id)`, `payments.list(**filters)` |
 | Enabled methods | `payments.methods(payment_method: nil)` |
-| Capture/preauthorization | `payments.capture(id, idempotency_key:, amount: nil)` |
-| Full/partial refund | `payments.refund(id, idempotency_key:, amount: nil, reason: nil)` |
+| Capture/preauthorization | `payments.capture(id, idempotency_key:)` |
+| Full/partial refund | `payments.refund(id, idempotency_key:, reason: nil)` |
 | Void authorization | `payments.void(id, idempotency_key:)` |
 | Split payment (1–5 legs) | `payments.split(body, idempotency_key:)` |
 | Split status/refund | `payments.get_split(id)`, `payments.refund_split(id, amount:, idempotency_key:, reason: nil)` |
@@ -91,17 +91,17 @@ The shared Lunixi form owns enabled payment methods and supports the methods con
 | Fraud transaction event | `fraud.record_event(body, idempotency_key:)` |
 | Other documented endpoints | `request(method, path, body: nil, query: {}, idempotency_key: nil, signed: true, binary: false)` |
 
-`amount`, split `totalAmount` and each leg/item price must be positive integers within JavaScript's safe integer range. Root `price`/`paidPrice` are removed fields and rejected even when null. Basket and split totals must agree. Intent installments belong to the checkout form; `installment` is rejected on intent creation. Set `preauth: true` for authorization, then capture separately with a new durable operation key. A nil capture/refund amount asks the gateway to use the remaining amount; zero, false, fractional and string amounts are rejected.
+`amount`, split `totalAmount` and each leg/item price must be positive canonical minor-unit strings within the signed 64-bit fiat range. Root `price`/`paidPrice` are removed fields and rejected even when null. Basket and split totals must agree. Intent installments belong to the checkout form; `installment` is rejected on intent creation. Set `preauth: true` for authorization, then capture separately with a new durable operation key. Omitting the capture/refund `amount:` keyword asks the gateway to use the remaining amount; explicit nil, numeric, zero, false and noncanonical string amounts are rejected.
 
 ```ruby
-lunixi.payments.refund('intent_123', amount: 2_500,
+lunixi.payments.refund('intent_123', amount: "2500",
                       reason: 'Customer request', idempotency_key: refund.persisted_operation_key)
 
 # Advanced transport: a documented existing endpoint, not a second HTTP stack.
 links = lunixi.request('GET', '/api/v1/payments/links', query: { limit: 20 })
 ```
 
-Payment, fraud and webhook helpers are explicit. Other products use the signed transport with the published gateway schema; version 0.1.2 does not claim full typed service-client parity with the PHP SDK. JSON is compact UTF-8 with JavaScript integer-index key ordering and compatible numeric formatting, so the signed bytes are exactly the transmitted bytes.
+Payment, fraud and webhook helpers are explicit. Other products use the signed transport with the published gateway schema; version 1.0.1 does not claim full typed service-client parity with the PHP SDK. JSON is compact UTF-8 with JavaScript integer-index key ordering and compatible numeric formatting, so the signed bytes are exactly the transmitted bytes.
 
 ## Raw-body webhooks and durable deduplication
 
@@ -154,8 +154,10 @@ The Rails example defaults to `LUNIXI_CHECKOUT_MODE=embedded`. It renders the ex
 
 Set `LUNIXI_CHECKOUT_MODE=hosted` explicitly for optional redirect. `Lunixi::Checkout.payment_page_url(data.fetch('paymentPageUrl'))` and the Rails redirect wrapper validate the exact backend URL: HTTPS `pay.lunixi.com/payment/` followed by a 16–4096-character ASCII opaque value, with no userinfo, port, query, fragment or controls. It can differ from the embedded token. Do not construct a URL from that token. Both modes expose the same merchant-enabled form methods, multi-card, installments and insurance; these features do not require redirecting. The existing fixed-total single-intent settlement limitation still applies.
 
-Run `rails db:migrate` before deploying 0.1.2. New request/mode/callback and start time are persisted before network I/O; request/token/backend URL use Active Record Encryption. Retries reuse the saved body and key and stop financial dispatch after 23 hours. Existing rows are marked legacy hosted; unknown legacy requests or missing backend URLs remain reconciliation-only, without rewriting origin, resetting a key or inventing a URL. Global mode changes affect new reservations; existing requests retain their saved presentation. CSRF/demo authorization, raw webhooks, native receipt transactions and the bounded 3DS/split return adapter remain unchanged.
+Run `rails db:migrate` before deploying 1.0.1. New request/mode/callback and start time are persisted before network I/O; request/token/backend URL use Active Record Encryption. Retries reuse the saved body and key and stop financial dispatch after 23 hours. Existing rows are marked legacy hosted; unknown legacy requests or missing backend URLs remain reconciliation-only, without rewriting origin, resetting a key or inventing a URL. Global mode changes affect new reservations; existing requests retain their saved presentation. CSRF/demo authorization, raw webhooks, native receipt transactions and the bounded 3DS/split return adapter remain unchanged.
 
-Focused 0.1.2 verification: 24 Rails form/return/URL/CSP security tests with 225 assertions, 2 SDK helper tests with 5 assertions, RuboCop and Brakeman (one exact documented strict-URL redirect false positive). Prior full 0.1.1 results remain the baseline; live/merchant acceptance is deferred.
+Historical focused 0.1.2 verification: 24 Rails form/return/URL/CSP security tests with 225 assertions, 2 SDK helper tests with 5 assertions, RuboCop and Brakeman (one exact documented strict-URL redirect false positive). Prior full 0.1.1 results remain the baseline; live/merchant acceptance is deferred.
 
 The checkout page’s CSP permits form POSTs only to `'self'` and the configured gateway origin (default `https://api-gateway.lunixi.com`). This preserves wallet/provider and legacy POST handoffs supported by the browser SDK. For another reviewed provider, set server-only `LUNIXI_FORM_ACTION_ORIGINS` to a comma-separated list of exact HTTPS origins, without spaces, paths, trailing slashes, credentials, query, fragment or wildcards. Invalid configuration fails closed; gateway responses and browser fields never expand this list. Script nonces, frame/connect restrictions and informational return handling remain in force.
+
+Before upgrading from 0.x, follow [the money-string migration](MIGRATION-1.0.md).

data/README.tr.md

@@ -4,20 +4,27 @@
 
 [English](README.md) · [Türkçe](README.tr.md) · [Dokümantasyon](https://docs.lunixi.com/tr/sdks/ruby) · [Rails örneği](samples/rails)
 
-Lunixi ödemeleri, fraud işlemleri ve imzalı gateway çağrıları için sunucu tarafı Ruby SDK’sı. Ed25519 imzasını OpenSSL ile üretir; token’ı eşzamanlı istekler arasında önbelleğe alır, tutarları tam sayı alt birimde korur ve güvenli tekrar denemelerde aynı idempotency anahtarını kullanır. v2 webhook doğrulaması özgün istek baytları üzerinden yapılır.
+Lunixi ödemeleri, fraud işlemleri ve imzalı gateway çağrıları için sunucu tarafı Ruby SDK’sı. Ed25519 imzasını OpenSSL ile üretir; token’ı eşzamanlı istekler arasında önbelleğe alır, tutarları kanonik alt birim string olarak korur ve güvenli tekrar denemelerde aynı idempotency anahtarını kullanır. v2 webhook doğrulaması özgün istek baytları üzerinden yapılır.
 
 ## Gereksinimler ve kurulum
 
 Ruby **3.3+**, **Ed25519** destekli OpenSSL ve Bundler gerekir. Çalıştırılabilir örnek **Rails 8.1** ve SQLite kullanır; ana gem Rails’e bağımlı değildir.
 
-**0.1.2** sürümü burada kaynak kod olarak dağıtılır. RubyGems yayını ayrı bir sürüm adımıdır; aşağıdaki kurulum kayıt deposunda yayımlanmış paket olduğunu varsaymaz.
+1.0.1 [RubyGems](https://rubygems.org/gems/lunixi-sdk) üzerinde kullanılabilir olduğunda `Gemfile` dosyanıza tam sürümü ekleyip `bundle install` çalıştırın. [Para sözleşmesi geçişini](MIGRATION-1.0.md) uygulayın:
+
+```ruby
+source 'https://rubygems.org'
+gem 'lunixi-sdk', '1.0.1'
+```
+
+İncelenen bağımlılık çözümünü korumak için `Gemfile.lock` dosyasını saklayın. Kaynak koddan kurulum alternatifi:
 
 ```bash
-git clone https://github.com/Lunixi-Payment/lunixi-ruby.git
+git clone --branch v1.0.1 --depth 1 https://github.com/Lunixi-Payment/lunixi-ruby.git
 cd lunixi-ruby
 bundle install
 gem build lunixi-sdk.gemspec
-gem install ./lunixi-sdk-0.1.2.gem
+gem install ./lunixi-sdk-1.0.1.gem
 ```
 
 Bu dizinde `bundle exec ruby …` yerel SDK’yı yükler. Uygulamanızın Gemfile’ında incelenmiş bir kopyayı `gem 'lunixi-sdk', path: '/tam/yol/lunixi-ruby'` ile kullanabilirsiniz. Bundler Git kaynağı kullanırken denetlenmiş commit’i sabitleyin.
@@ -49,16 +56,16 @@ Toplamı sunucuda hesaplayın. Çağrıdan **önce** ödeme denemesine bir UUID
 
 ```ruby
 result = lunixi.payments.create_intent(
-  { amount: 10_050, currency: 'TRY', orderId: order.public_id,
+  { amount: "10050", currency: 'TRY', orderId: order.public_id,
     callbackUrl: 'https://merchant.example/payments/return',
-    basketItems: [{ id: 'urun-1', name: 'Product', itemType: 'PHYSICAL', price: 10_050 }] },
+    basketItems: [{ id: 'urun-1', name: 'Product', itemType: 'PHYSICAL', price: "10050" }] },
   idempotency_key: order.persisted_payment_attempt_key
 )
 intent_id = result.fetch('data').fetch('paymentId')
 checkout_token = result.fetch('data').fetch('token')
 ```
 
-`10_050`, 100,50 TRY’nin kuruş karşılığıdır. Tutarlar pozitif ve JavaScript güvenli tam sayı aralığında olmalıdır; float/string kabul edilmez. Eski kök `price`/`paidPrice` alanları null olsa bile reddedilir. Sepet toplamı ve split bacak toplamı ana tutarla aynı olmalıdır. Intent’te `installment` gönderilmez; taksiti ödeme formu seçtirir. `preauth: true` ile provizyon alınabilir; capture ayrı işlem ve anahtarla yapılır.
+`"10050"`, 100,50 TRY’nin kuruş karşılığıdır. Tutarlar pozitif, kanonik alt birim string olmalı ve işaretli 64 bit fiat aralığında kalmalıdır; sayısal değerler kabul edilmez. Eski kök `price`/`paidPrice` alanları null olsa bile reddedilir. Sepet toplamı ve split bacak toplamı ana tutarla aynı olmalıdır. Intent’te `installment` gönderilmez; taksiti ödeme formu seçtirir. `preauth: true` ile provizyon alınabilir; capture ayrı işlem ve anahtarla yapılır.
 
 Varsayılan form mağaza içinde açılır; isteğe bağlı yönlendirme yalnız doğrulanmış backend `paymentPageUrl` adresini kullanır. Token ve adres şifrelenir; iki mod aynı Lunixi form ayarlarını paylaşır. PAN/CVV toplamayın.
 
@@ -71,15 +78,15 @@ HTTP 2xx, token, dönüş sayfası veya devam eden split durumu tahsilat kanıt
 | Intent oluşturma | `payments.create_intent(body, idempotency_key:)` |
 | Ödeme okuma/listeleme | `payments.get(id)`, `payments.list(**filters)` |
 | Açık yöntemler | `payments.methods(payment_method: nil)` |
-| Capture | `payments.capture(id, idempotency_key:, amount: nil)` |
-| Tam/kısmi iade | `payments.refund(id, idempotency_key:, amount: nil, reason: nil)` |
+| Capture | `payments.capture(id, idempotency_key:)` |
+| Tam/kısmi iade | `payments.refund(id, idempotency_key:, reason: nil)` |
 | Provizyon iptali | `payments.void(id, idempotency_key:)` |
 | Çoklu ödeme | `payments.split(body, idempotency_key:)` |
 | Split durum/iade | `payments.get_split(id)`, `payments.refund_split(id, amount:, idempotency_key:, reason: nil)` |
 | Fraud | `fraud.evaluate(body)`, `fraud.record_event(body, idempotency_key:)` |
 | Diğer dokümante uçlar | `request(method, path, body: nil, query: {}, idempotency_key: nil, signed: true, binary: false)` |
 
-Capture/iade için `amount: nil`, gateway’in kalan tutarı kullanmasını ister. `0`, `false`, float ve string tutar reddedilir. Her capture/iade/iptal için ayrı ve kalıcı işlem anahtarı gerekir. Yanıt zarfı korunur. Payment, fraud ve webhook yardımcıları açıktır; diğer servisler dokümante şema ile imzalı transport üzerinden çağrılır. Bu sürüm PHP SDK’sındaki tüm servisler için ayrı tipli istemci sunduğunu iddia etmez.
+Capture/iade için `amount:` anahtarını göndermemek, gateway’in kalan tutarı kullanmasını ister; açık `amount: nil` reddedilir. `"0"`, `false`, sayısal değerler ve kanonik olmayan string tutar reddedilir. Her capture/iade/iptal için ayrı ve kalıcı işlem anahtarı gerekir. Yanıt zarfı korunur. Payment, fraud ve webhook yardımcıları açıktır; diğer servisler dokümante şema ile imzalı transport üzerinden çağrılır. Bu sürüm PHP SDK’sındaki tüm servisler için ayrı tipli istemci sunduğunu iddia etmez.
 
 ## Webhook güvenliği
 
@@ -127,8 +134,8 @@ Rails örneğinde varsayılan `LUNIXI_CHECKOUT_MODE=embedded` değeridir. Mevcut
 
 İsteğe bağlı yönlendirme için açıkça `LUNIXI_CHECKOUT_MODE=hosted` seçin. `Lunixi::Checkout.payment_page_url(data.fetch('paymentPageUrl'))` backend adresini birebir doğrular: HTTPS `pay.lunixi.com/payment/` ve 16–4096 karakter ASCII opak değer; userinfo, port, sorgu, fragment veya kontrol karakteri kabul edilmez. Bu değer gömülü token'dan farklı olabilir; token'dan URL üretilmez. İki mod aynı açık yöntemleri, çoklu kartı, taksiti ve sigortayı sunar; yönlendirme şart değildir. Sabit toplamlı tek-intent tahsilat sınırlaması korunur.
 
-0.1.2'yi açmadan önce `rails db:migrate` çalıştırın. Yeni istek/mod/dönüş adresi/zaman ağdan önce kaydedilir; gövde, token ve backend adresi Active Record Encryption ile şifrelenir. Tekrar aynı gövde/anahtarla gider; 23 saatten eski finansal gönderim durur. Mevcut satırlar eski hosted akışı olarak işaretlenir; bilinmeyen eski istek veya eksik backend adresi origin/anahtar değiştirilmeden ve adres üretilmeden mutabakat bekler. Genel mod değişikliği yeni rezervasyonlara uygulanır; mevcut istek kayıtlı modunu korur. CSRF/demo yetkisi, ham webhook, atomik receipt ve sınırlı 3DS/çoklu kart dönüşü korunur.
+Rails örneğini yükseltmeden önce `rails db:migrate` çalıştırın. Yeni istek/mod/dönüş adresi/zaman ağdan önce kaydedilir; gövde, token ve backend adresi Active Record Encryption ile şifrelenir. Tekrar aynı gövde/anahtarla gider; 23 saatten eski finansal gönderim durur. Mevcut satırlar eski hosted akışı olarak işaretlenir; bilinmeyen eski istek veya eksik backend adresi origin/anahtar değiştirilmeden ve adres üretilmeden mutabakat bekler. Genel mod değişikliği yeni rezervasyonlara uygulanır; mevcut istek kayıtlı modunu korur. CSRF/demo yetkisi, ham webhook, atomik receipt ve sınırlı 3DS/çoklu kart dönüşü korunur.
 
-0.1.2 odaklı kontrolü: 24 Rails form/dönüş/URL/CSP güvenlik testi ve 225 assertion, 2 SDK yardımcı testi ve 5 assertion, RuboCop ve Brakeman (belgeli tek strict-URL yönlendirme false positive'i). Önceki tam 0.1.1 sonuçları temel kanıttır; canlı/merchant kabulü ertelenmiştir.
+Geçmiş 0.1.2 odaklı kontrolü: 24 Rails form/dönüş/URL/CSP güvenlik testi ve 225 assertion, 2 SDK yardımcı testi ve 5 assertion, RuboCop ve Brakeman (belgeli tek strict-URL yönlendirme false positive'i). Önceki tam 0.1.1 sonuçları temel kanıttır; canlı/merchant kabulü ertelenmiştir.
 
 Checkout sayfasının CSP’si form POST’u için yalnız `'self'` ve yapılandırılan gateway origin’ine (varsayılan `https://api-gateway.lunixi.com`) izin verir. Böylece tarayıcı SDK’sının desteklediği cüzdan/sağlayıcı ve eski POST geçişleri korunur. İncelenmiş başka bir sağlayıcı gerekiyorsa yalnız sunucuda `LUNIXI_FORM_ACTION_ORIGINS` tanımlayın: virgülle ayrılmış tam HTTPS origin’leri; boşluk, yol, sondaki slash, kullanıcı bilgisi, sorgu, fragment ve wildcard kabul edilmez. Geçersiz ayar reddedilir; gateway yanıtı veya tarayıcı alanı listeyi genişletemez. Script nonce, frame/connect sınırları ve bilgilendirici dönüş güvenliği korunur.

data/docs/PUBLISHING.md

@@ -1,8 +1,8 @@
 # RubyGems publication
 
-`publish-rubygems.yml` is a manual, main-branch-only workflow for a tested version tag. It checks the exact tag's successful CI, gem identity/version and package contents before requesting a short-lived registry credential. No permanent API key is stored in the repository.
+`publish-rubygems.yml` is a manual workflow dispatched from the exact release tag. For 1.0.1, select `v1.0.1` and enter `1.0.1`. It resolves the tag to the invocation SHA, requires successful public push CI for that same commit, then checks out the immutable source. Gem identity/version and SHA-256 are verified before publishing. No permanent API key is stored in the repository.
 
-For the first `lunixi-sdk` release, sign in with the intended confirmed RubyGems account and configure its pending trusted publisher. The account must satisfy the registry MFA requirement and becomes the gem's initial owner.
+Use the existing account-owned trusted publisher for `lunixi-sdk`. Its authorized scope is listed below; registry publication does not require creating a second publisher.
 
 | Setting | Value |
 | --- | --- |
@@ -12,9 +12,23 @@ For the first `lunixi-sdk` release, sign in with the intended confirmed RubyGems
 | Environment | `release` |
 | Reusable workflow fields | Blank |
 
-The account owner must review and authorize this package-specific publishing delegation. The workflow alone does not create the publisher or publish a gem. After authorization, run it from `main` with version `0.1.1`; it refuses a version that already exists. Verify the resulting version and downloaded gem digest from RubyGems.
+The approved initial account is asserted by immutable RubyGems **owner ID `255358`**. The exchange sends `owner` as the JSON string `"255358"`; RubyGems rejects a JSON number and resolves all-digit strings by immutable ID rather than by a reusable handle.
+
+The released `configure-rubygems-credentials` **v2.1.0** does not expose an owner input: its [pinned action definition](https://github.com/rubygems/configure-rubygems-credentials/blob/dc5a8d8553e6ee01fc26761a49e99e733d17954a/action.yml) and [exchange implementation](https://github.com/rubygems/configure-rubygems-credentials/blob/dc5a8d8553e6ee01fc26761a49e99e733d17954a/src/oidc/trustedPublisher.ts) send only the JWT. Until an owner-capable release is reviewed, the workflow embeds a Python-standard-library exchange before its push step. It requests a GitHub ID token for audience `rubygems.org`, then POSTs only `{jwt, owner}` to the fixed HTTPS endpoint `https://rubygems.org/api/v1/oidc/trusted_publisher/exchange_token`.
+
+The contract was checked against the [RubyGems controller at commit `5a641a1e1ac8bd37ba0b11d56b5d7ee379107f85`](https://github.com/rubygems/rubygems.org/blob/5a641a1e1ac8bd37ba0b11d56b5d7ee379107f85/app/controllers/api/v1/oidc/trusted_publisher_controller.rb) and its [owner-binding regression tests](https://github.com/rubygems/rubygems.org/blob/5a641a1e1ac8bd37ba0b11d56b5d7ee379107f85/test/integration/api/v1/oidc/trusted_publisher_controller_test.rb). The server verifies the signed OIDC claims, atomically binds the asserted owner, rejects replay of the same token, and issues a **push-only, 15-minute** credential with HTTP **201**. The workflow rejects redirects, other HTTP statuses, malformed/oversized responses, additional scopes and expiry beyond 16 minutes. It masks request/JWT/API credentials before use, exports only `GEM_HOST_API_KEY` through a mode-600 runner environment file, and never logs HTTP bodies or underlying exception details. It creates no permanent API key and does not alter the publisher's permissions.
+
+The account owner must review and authorize this package-specific publishing delegation. The workflow alone does not create the publisher or publish a gem. For an authorized release, run it from the matching `v1.0.1` tag with version `1.0.1`; it refuses a version that already exists. Verify the resulting version and downloaded gem digest from RubyGems.
 
 The build does not repeat the functional suite. Ephemeral runner credentials are removed after the upload.
 
+## Verified 0.1.2 publication
+
+The account owner authorized the exact publisher above. [Publish run 41249047391](https://github.com/Lunixi-Payment/lunixi-ruby/actions/runs/41249047391) completed successfully from workflow commit `7a4a0e7b6f647490f7f09b650847c38f0b7d3b19`, while the package checkout remained pinned to `579cdf8afeaad0cdba2764c312005bc60480227b`. The original `v0.1.2` tag is unchanged.
+
+[RubyGems 0.1.2](https://rubygems.org/gems/lunixi-sdk/versions/0.1.2) is available with SHA-256 `c9c6386c03a3b853d56335c2f21e91f18d3450a83906d5ad15d9fc07ac1ce16f`. That historical release remains immutable. The current workflow also refuses an already published version.
+
+The downloaded 39,424-byte archive matches the registry checksum. All 23 packaged files match both the prepared gem and the immutable release source; build metadata can differ between independently built archives.
+
 - [Trusted Publishing and pending publishers](https://guides.rubygems.org/trusted-publishing/)
 - [RubyGems publishing](https://guides.rubygems.org/publishing/)

data/docs/ruby.en.md

@@ -1,6 +1,6 @@
 ---
 title: Ruby SDK
-description: Lunixi Ruby SDK — source installation, Ed25519 signing, payments, fraud, durable idempotency and raw-body v2 webhooks.
+description: Lunixi Ruby SDK — installation, Ed25519 signing, payments, fraud, durable idempotency and raw-body v2 webhooks.
 ---
 
 
@@ -8,20 +8,19 @@ description: Lunixi Ruby SDK — source installation, Ed25519 signing, payments,
 
 `lunixi-sdk` is a server-side Ruby client for Lunixi. It handles OpenSSL Ed25519 request signing, synchronized token caching, compact JavaScript-compatible JSON, safe retries and raw-body webhook verification. It works with Rails, Sinatra, Rack and plain Ruby. The core gem has no framework dependency; the executable [Rails integration](/sdks/rails) is included in the source repository.
 
-## Requirements and source installation
+## Requirements and installation
 
 Ruby **3.3+**, Bundler and an OpenSSL build supporting **Ed25519** are required. The Rails example uses Rails 8.1.
 
-> 
-Version 0.1.1 is distributed from source. RubyGems publication is a separate release step; a registry install is not assumed here.
+After 1.0.1 is available on RubyGems, add `gem 'lunixi-sdk', '1.0.1'` to your Gemfile and run `bundle install`. Follow the [money-string migration](../MIGRATION-1.0.md). The following source build is an optional development workflow:
 
 
 ```bash
-git clone https://github.com/Lunixi-Payment/lunixi-ruby.git
+git clone --branch v1.0.1 --depth 1 https://github.com/Lunixi-Payment/lunixi-ruby.git
 cd lunixi-ruby
 bundle install
 gem build lunixi-sdk.gemspec
-gem install ./lunixi-sdk-0.1.1.gem
+gem install ./lunixi-sdk-1.0.1.gem
 ```
 
 Source: [Lunixi-Payment/lunixi-ruby](https://github.com/Lunixi-Payment/lunixi-ruby). An application may also use a reviewed local checkout with `gem 'lunixi-sdk', path: '/absolute/path/to/lunixi-ruby'`. Pin an audited commit if you use a Bundler Git source.
@@ -59,11 +58,11 @@ Persist the payment attempt and its UUID idempotency key before the first reques
 ```ruby
 result = lunixi.payments.create_intent(
   {
-    amount: 10_050,
+    amount: "10050",
     currency: 'TRY',
     orderId: order.public_id,
     callbackUrl: 'https://merchant.example/payments/return',
-    basketItems: [{ id: 'item-1', name: 'Product', itemType: 'PHYSICAL', price: 10_050 }]
+    basketItems: [{ id: 'item-1', name: 'Product', itemType: 'PHYSICAL', price: "10050" }]
   },
   idempotency_key: order.persisted_payment_attempt_key
 )
@@ -78,7 +77,7 @@ checkout_token = result.fetch('data').fetch('token')
 An intent/token, HTTP 2xx, return URL or intermediate split state does not prove capture. Correlate a verified webhook with the persisted order and authenticate a payment status read; confirm final status, amount and currency before fulfillment.
 
 
-Amounts must be positive integers within JavaScript's safe integer range. Root `price` and `paidPrice` are rejected even when null. Basket prices and split leg amounts must equal the relevant total. Intent `installment` is rejected because installments are selected in the checkout form. `preauth: true` requests authorization; capture is a separate operation.
+Amounts must be positive canonical minor-unit strings within the signed 64-bit fiat range. Root `price` and `paidPrice` are rejected even when null. Basket prices and split leg amounts must equal the relevant total. Intent `installment` is rejected because installments are selected in the checkout form. `preauth: true` requests authorization; capture is a separate operation.
 
 ## Available helpers
 
@@ -87,15 +86,15 @@ Amounts must be positive integers within JavaScript's safe integer range. Root `
 | Create an intent | `lunixi.payments.create_intent(body, idempotency_key:)` |
 | Read/list payments | `lunixi.payments.get(id)`, `lunixi.payments.list(**filters)` |
 | Merchant methods | `lunixi.payments.methods(payment_method: nil)` |
-| Capture | `lunixi.payments.capture(id, idempotency_key:, amount: nil)` |
-| Full/partial refund | `lunixi.payments.refund(id, idempotency_key:, amount: nil, reason: nil)` |
+| Capture | `lunixi.payments.capture(id, idempotency_key:)` |
+| Full/partial refund | `lunixi.payments.refund(id, idempotency_key:, reason: nil)` |
 | Void | `lunixi.payments.void(id, idempotency_key:)` |
 | Split payment | `lunixi.payments.split(body, idempotency_key:)` |
 | Split status/refund | `lunixi.payments.get_split(id)`, `lunixi.payments.refund_split(id, amount:, idempotency_key:, reason: nil)` |
 | Fraud | `lunixi.fraud.evaluate(body)`, `lunixi.fraud.record_event(body, idempotency_key:)` |
 | Advanced signed HTTP | `lunixi.request(method, path, body: nil, query: {}, idempotency_key: nil, signed: true, binary: false)` |
 
-Capture/refund `amount: nil` asks the gateway to use the remaining amount. False, zero, string and fractional amounts are rejected. Persist a separate operation key for each capture, refund or void. Running split HTTP 400 protocol responses are returned only for documented running states; they remain pending, not paid. Response envelopes are preserved.
+Omit the capture/refund `amount:` keyword to use the remaining amount. Explicit nil, false, zero, numeric and noncanonical string amounts are rejected. Persist a separate operation key for each capture, refund or void. Running split HTTP 400 protocol responses are returned only for documented running states; they remain pending, not paid. Response envelopes are preserved.
 
 The advanced transport supports other **documented** gateway routes without a second HTTP implementation:
 

data/docs/ruby.tr.md

@@ -1,6 +1,6 @@
 ---
 title: Ruby SDK
-description: Lunixi Ruby SDK — kaynak kurulum, Ed25519 imza, ödeme ve fraud, kalıcı idempotency ve özgün baytlarla v2 webhook doğrulama.
+description: Lunixi Ruby SDK — kurulum, Ed25519 imza, ödeme ve fraud, kalıcı idempotency ve özgün baytlarla v2 webhook doğrulama.
 ---
 
 
@@ -8,20 +8,19 @@ description: Lunixi Ruby SDK — kaynak kurulum, Ed25519 imza, ödeme ve fraud,
 
 `lunixi-sdk`, Lunixi için sunucu tarafı Ruby istemcisidir. Ed25519 imzayı OpenSSL ile üretir; token’ı eşzamanlı istekler arasında saklar, kompakt JavaScript uyumlu JSON oluşturur, güvenli tekrar denemeleri ve özgün baytlarla webhook doğrulamayı sağlar. Rails, Sinatra, Rack ve düz Ruby ile çalışır. Ana gem çerçeveden bağımsızdır; kaynak depodaki çalıştırılabilir [Rails örneği](/sdks/rails) ayrı adaptördür.
 
-## Gereksinimler ve kaynak kurulum
+## Gereksinimler ve kurulum
 
 Ruby **3.3+**, Bundler ve **Ed25519** destekli OpenSSL gerekir. Rails örneği Rails 8.1 kullanır.
 
-> 
-0.1.1 kaynak kod üzerinden dağıtılır. RubyGems yayını ayrı bir sürüm adımıdır; aşağıdaki kurulum yayımlanmış bir registry paketi varsaymaz.
+1.0.1 RubyGems üzerinde kullanılabilir olduğunda Gemfile’a `gem 'lunixi-sdk', '1.0.1'` ekleyip `bundle install` çalıştırın. [Para sözleşmesi geçişini](../MIGRATION-1.0.md) uygulayın. Aşağıdaki kaynak derlemesi geliştirme için isteğe bağlıdır:
 
 
 ```bash
-git clone https://github.com/Lunixi-Payment/lunixi-ruby.git
+git clone --branch v1.0.1 --depth 1 https://github.com/Lunixi-Payment/lunixi-ruby.git
 cd lunixi-ruby
 bundle install
 gem build lunixi-sdk.gemspec
-gem install ./lunixi-sdk-0.1.1.gem
+gem install ./lunixi-sdk-1.0.1.gem
 ```
 
 Kaynak: [Lunixi-Payment/lunixi-ruby](https://github.com/Lunixi-Payment/lunixi-ruby). İncelenmiş yerel kopyayı `gem 'lunixi-sdk', path: '/tam/yol/lunixi-ruby'` ile kullanabilirsiniz. Bundler Git kaynağı kullanırken denetlenmiş commit’i sabitleyin.
@@ -59,11 +58,11 @@ Public anahtarı Lunixi paneline kaydedip verilen key id’yi kullanın. Özel a
 ```ruby
 result = lunixi.payments.create_intent(
   {
-    amount: 10_050,
+    amount: "10050",
     currency: 'TRY',
     orderId: order.public_id,
     callbackUrl: 'https://merchant.example/payments/return',
-    basketItems: [{ id: 'item-1', name: 'Product', itemType: 'PHYSICAL', price: 10_050 }]
+    basketItems: [{ id: 'item-1', name: 'Product', itemType: 'PHYSICAL', price: "10050" }]
   },
   idempotency_key: order.persisted_payment_attempt_key
 )
@@ -78,7 +77,7 @@ checkout_token = result.fetch('data').fetch('token')
 Intent/token, HTTP 2xx, dönüş sayfası veya ara split durumu tahsilat kanıtı değildir. İmzalı webhook’u kalıcı siparişle eşleştirin; sunucudan ödeme sorgusunda nihai durum, tutar ve para birimi uyuşmadan siparişi tamamlamayın.
 
 
-Tutarlar pozitif ve JavaScript güvenli tam sayı aralığında olmalıdır. Kök `price`/`paidPrice` null olsa bile reddedilir. Sepet ve split bacak toplamları ana toplamla aynı olmalıdır. Intent’te `installment` gönderilmez; taksit formda seçilir. `preauth: true` provizyon ister; capture ayrı işlemdir.
+Tutarlar pozitif, kanonik alt birim string olmalı ve işaretli 64 bit fiat aralığında kalmalıdır. Kök `price`/`paidPrice` null olsa bile reddedilir. Sepet ve split bacak toplamları ana toplamla aynı olmalıdır. Intent’te `installment` gönderilmez; taksit formda seçilir. `preauth: true` provizyon ister; capture ayrı işlemdir.
 
 ## Yardımcı API’ler
 
@@ -87,15 +86,15 @@ Tutarlar pozitif ve JavaScript güvenli tam sayı aralığında olmalıdır. Kö
 | Intent | `lunixi.payments.create_intent(body, idempotency_key:)` |
 | Ödeme okuma/liste | `lunixi.payments.get(id)`, `lunixi.payments.list(**filters)` |
 | Açık yöntemler | `lunixi.payments.methods(payment_method: nil)` |
-| Capture | `lunixi.payments.capture(id, idempotency_key:, amount: nil)` |
-| Tam/kısmi iade | `lunixi.payments.refund(id, idempotency_key:, amount: nil, reason: nil)` |
+| Capture | `lunixi.payments.capture(id, idempotency_key:)` |
+| Tam/kısmi iade | `lunixi.payments.refund(id, idempotency_key:, reason: nil)` |
 | Provizyon iptali | `lunixi.payments.void(id, idempotency_key:)` |
 | Split | `lunixi.payments.split(body, idempotency_key:)` |
 | Split durum/iade | `lunixi.payments.get_split(id)`, `lunixi.payments.refund_split(id, amount:, idempotency_key:, reason: nil)` |
 | Fraud | `lunixi.fraud.evaluate(body)`, `lunixi.fraud.record_event(body, idempotency_key:)` |
 | İmzalı genel HTTP | `lunixi.request(method, path, body: nil, query: {}, idempotency_key: nil, signed: true, binary: false)` |
 
-Capture/iade `amount: nil`, kalan tutarın gateway tarafından kullanılmasını ister. False, sıfır, string ve kesirli tutar reddedilir. Her capture/iade/iptal için ayrı, kalıcı anahtar saklayın. Belgelenmiş devam eden split durumlarındaki HTTP 400 yanıtları protokol sonucu olarak döndürülür; ödenmiş sayılmaz. Yanıt zarfı korunur.
+Capture/iade `amount:` anahtarı gönderilmezse kalan tutar kullanılır; açık `amount: nil` reddedilir. False, sıfır, sayısal değerler ve kanonik olmayan string tutar reddedilir. Her capture/iade/iptal için ayrı, kalıcı anahtar saklayın. Belgelenmiş devam eden split durumlarındaki HTTP 400 yanıtları protokol sonucu olarak döndürülür; ödenmiş sayılmaz. Yanıt zarfı korunur.
 
 Diğer **dokümante** gateway uçları aynı imzalı transport üzerinden çağrılabilir:
 

data/lib/lunixi/client.rb

@@ -39,6 +39,11 @@ module Lunixi
 
       path = safe_path(path, query)
       key = self.class.idempotency_key!(idempotency_key) if idempotency_key
+      Money.validate_operation_amount(path, body)
+      if Money.fiat_route?(path)
+        Money.validate_fields(body)
+        Money.validate_fields(query)
+      end
       bytes = body.nil? ? nil : JsonBody.dump(body)
       raise ConfigurationError, 'Request body exceeds the size limit' if bytes && bytes.bytesize > 1024 * 1024
 
@@ -77,7 +82,7 @@ module Lunixi
           retries += 1
           next
         end
-        return decode_response(response, binary: binary, running_split: method == 'POST' && path == '/api/v1/payments/split')
+        return decode_response(response, binary: binary, fiat: Money.fiat_route?(path), running_split: method == 'POST' && path == '/api/v1/payments/split')
       rescue TransportError
         raise unless safe_to_retry && retries < @max_retries
 
@@ -187,15 +192,20 @@ module Lunixi
       @sleeper.call(seconds)
     end
 
-    def decode_response(response, binary: false, running_split: false)
+    def response_payload(response)
+      payload = response.body.empty? ? {} : JSON.parse(response.body, max_nesting: 64)
+      raise ApiError.new(status: response.status, code: 'invalid_json_response') unless payload.is_a?(Hash)
+
+      payload
+    rescue JSON::ParserError
+      raise ApiError.new(status: response.status, code: 'invalid_json_response'), cause: nil
+    end
+
+    def decode_response(response, binary: false, running_split: false, fiat: false)
       return response.body.b.freeze if binary && response.status.between?(200, 299)
 
-      begin
-        payload = response.body.empty? ? {} : JSON.parse(response.body, max_nesting: 64)
-      rescue JSON::ParserError
-        raise ApiError.new(status: response.status, code: 'invalid_json_response'), cause: nil
-      end
-      raise ApiError.new(status: response.status, code: 'invalid_json_response') unless payload.is_a?(Hash)
+      payload = response_payload(response)
+      Money.validate_fields(payload, response: true) if fiat
       return payload if response.status.between?(200, 299)
 
       error_class = case response.status

data/lib/lunixi/money.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Lunixi
+  # Canonical public fiat money. Arithmetic uses Ruby's exact Integer only after validation.
+  module Money
+    MAX = 9_223_372_036_854_775_807
+    EXPONENTS = %w[TRY USD EUR GBP RUB AED SAR QAR CHF CAD AUD CNY AZN].to_h { |c| [c, 2] }.merge('JPY' => 0, 'KWD' => 3).freeze
+    module_function
+
+    def fiat_route?(path)
+      path.match?(%r{\A/api/v1/(?:payments|wallet|insurance|bank-connect|fraud)(?:[/?]|\z)})
+    end
+
+    def validate_operation_amount(path, body)
+      return unless path.match?(%r{\A/api/v1/payments/(?:split/)?[^/]+/(?:capture|refund)(?:[?]|\z)}) && body.is_a?(Hash)
+
+      body.each { |key, value| minor(value) if key.to_s == 'amount' }
+    end
+
+    def minor(value, positive: true, signed: false)
+      pattern = if signed
+                  /\A(?:0|-?[1-9][0-9]*)\z/
+                elsif positive
+                  /\A[1-9][0-9]*\z/
+                else
+                  /\A(?:0|[1-9][0-9]*)\z/
+                end
+      unless value.is_a?(String) && value.match?(pattern) && value.to_i.between?(-MAX - 1, MAX)
+        raise ConfigurationError, 'Canonical minor-unit string in the signed 64-bit fiat range required'
+      end
+
+      value
+    end
+
+    def decimal_to_minor(value, currency)
+      exponent = EXPONENTS.fetch(currency) { raise ConfigurationError, 'Unsupported currency' }
+      raise ConfigurationError, 'Exact decimal text required' unless value.is_a?(String) && value.match?(/\A(?:0|[1-9][0-9]*)(?:\.[0-9]+)?\z/)
+
+      whole, fraction = value.split('.', 2)
+      fraction ||= ''
+      raise ConfigurationError, 'Fractional minor units' if fraction[exponent..]&.match?(/[1-9]/)
+
+      minor((whole + fraction[0, exponent].ljust(exponent, '0')).to_i.to_s, positive: false)
+    end
+
+    def validate_fields(value, response: false)
+      case value
+      when Array
+        value.each { |entry| validate_fields(entry, response: response) }
+      when Hash
+        value.each do |name, entry|
+          key = name.to_s
+          next if entry.nil? || %w[metadata fields inputFields insuranceData].include?(key)
+
+          if %w[
+            amount amountMinor authorizedAmount availableBalance balanceMinor buyerTotalCharge cancelledPremiumAmount
+            capturedAmount capturedAmountMinor chargeAmount collectedAmountMinor collectedPremiumAmount compensatedAmount
+            disputedAmount feeTotal fixedFee inForcePremiumAmount insuranceValueAmount legAmount legsAmount lineTotalMinor
+            maxAmount maxAmountMinor minAmount minAmountMinor nonRefundableAmount paidAmount paidPrice pendingBalance
+            premiumAmount price refundAmount refundOpenPremiumAmount refundableAmount refundedAmount refundedAmountMinor
+            refundedPremiumAmount requestedAmount reservedBalance sourceAmountMinor targetAmountMinor taxAmountMinor taxTotal
+            totalAmount unitPriceMinor
+          ].include?(key)
+            minor(entry, positive: !response && %w[amount price totalAmount].include?(key), signed: key.downcase.include?('balance'))
+          elsif %w[
+            data details items rows results payments operations balances wallets legs aggregate refund refunds totals
+            charge fees fee balance splits sellers basketItems promissoryNote schedule notes lines offers policies
+            reconciliation quotes payment transactions accounts settlements payouts limits
+          ].include?(key)
+            validate_fields(entry, response: response)
+          end
+        end
+      end
+      value
+    end
+  end
+end

data/lib/lunixi/payments.rb

@@ -5,6 +5,8 @@ module Lunixi
   # documented endpoints without pretending to validate their entire DTO schema.
   class Payments
     BASE = '/api/v1/payments'
+    OMITTED_AMOUNT = Object.new.freeze
+    private_constant :OMITTED_AMOUNT
     attr_reader :client
 
     def initialize(client)
@@ -36,17 +38,17 @@ module Lunixi
       client.request('GET', "#{BASE}/methods", query: query)
     end
 
-    # Capture an authorization; nil amount requests the gateway's remaining amount.
-    def capture(payment_id, idempotency_key:, amount: nil)
+    # Omit amount to capture the remaining authorization; explicit nil is invalid.
+    def capture(payment_id, idempotency_key:, amount: OMITTED_AMOUNT)
       body = { 'paymentIntentId' => identifier!(payment_id) }
-      body['amount'] = minor!(amount) unless amount.nil?
+      body['amount'] = minor!(amount) unless amount.equal?(OMITTED_AMOUNT)
       client.request('POST', "#{BASE}/#{payment_id}/capture", body: body, idempotency_key: Client.idempotency_key!(idempotency_key))
     end
 
     # Refund captured funds; persist a separate key for each refund operation.
-    def refund(payment_id, idempotency_key:, amount: nil, reason: nil)
+    def refund(payment_id, idempotency_key:, amount: OMITTED_AMOUNT, reason: nil)
       body = { 'paymentIntentId' => identifier!(payment_id) }
-      body['amount'] = minor!(amount) unless amount.nil?
+      body['amount'] = minor!(amount) unless amount.equal?(OMITTED_AMOUNT)
       body['reason'] = reason!(reason) unless reason.nil?
       client.request('POST', "#{BASE}/#{payment_id}/refund", body: body, idempotency_key: Client.idempotency_key!(idempotency_key))
     end
@@ -68,9 +70,9 @@ module Lunixi
       total = legs.sum do |leg|
         raise ConfigurationError, 'Split legs must be objects' unless leg.is_a?(Hash)
 
-        minor!(leg['amount'])
+        minor!(leg['amount']).to_i
       end
-      raise ConfigurationError, 'Split leg amounts must equal totalAmount' unless total == data['totalAmount']
+      raise ConfigurationError, 'Split leg amounts must equal totalAmount' unless total == data['totalAmount'].to_i
 
       client.request('POST', "#{BASE}/split", body: data, idempotency_key: Client.idempotency_key!(idempotency_key))
     end
@@ -97,11 +99,7 @@ module Lunixi
     end
 
     def minor!(value)
-      unless value.is_a?(Integer) && value.positive? && value <= JsonBody::MAX_SAFE_INTEGER
-        raise ConfigurationError, 'Amount must be a positive safe integer in minor units'
-      end
-
-      value
+      Money.minor(value)
     end
 
     def currency!(value)
@@ -155,9 +153,9 @@ module Lunixi
       total = items.sum do |item|
         raise ConfigurationError, 'Basket items must be objects' unless item.is_a?(Hash)
 
-        minor!(item['price'])
+        minor!(item['price']).to_i
       end
-      raise ConfigurationError, 'Basket total must equal amount' unless total == amount
+      raise ConfigurationError, 'Basket total must equal amount' unless total == amount.to_i
     end
   end
 end

data/lib/lunixi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lunixi
-  VERSION = '0.1.2'
+  VERSION = '1.0.1'
 end

data/lib/lunixi.rb

@@ -3,6 +3,7 @@
 require_relative 'lunixi/version'
 require_relative 'lunixi/errors'
 require_relative 'lunixi/json_body'
+require_relative 'lunixi/money'
 require_relative 'lunixi/signer'
 require_relative 'lunixi/transport'
 require_relative 'lunixi/payments'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lunixi-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.1
 platform: ruby
 authors:
 - Lunixi
@@ -101,6 +101,7 @@ files:
 - ".github/assets/lunixi-logo.svg"
 - CHANGELOG.md
 - LICENSE
+- MIGRATION-1.0.md
 - README.md
 - README.tr.md
 - SECURITY.md
@@ -115,6 +116,7 @@ files:
 - lib/lunixi/errors.rb
 - lib/lunixi/fraud.rb
 - lib/lunixi/json_body.rb
+- lib/lunixi/money.rb
 - lib/lunixi/payments.rb
 - lib/lunixi/signer.rb
 - lib/lunixi/transport.rb