opentrust 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: de6fbba7e9eebcb29951eabb63212c48696ed16e3ee6c0fbf98e4be0f3b8ba9f
+  data.tar.gz: 273707de6ff17306d6a8284d02a1d1fef3e85459d5be6f27a81991f5ebfb0571
+SHA512:
+  metadata.gz: 0e60f2550129dace80d3e3e5ae14db4f178301bacea8e470544a3cc6f3b98dbf29e0c1a7c1a8a124a76b1ff5317b64afb8106724560d398aca8e5e2a3f5302a6
+  data.tar.gz: e7e639909140db87ebd47b66df031e5805218420a9a5be1ded69c48d0b8c4eb1b75d2f4f346d5924ac35e7aa32df39242edd6483752c765da7abd4632c9d102f

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parity Cube Pvt Ltd and OpenTrust contributors
+
+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,42 @@
+# opentrust (Ruby)
+
+Check mobile numbers against experiences shared by other Indian merchants, and share your own. No dependencies.
+
+```ruby
+# Gemfile
+gem "opentrust"
+```
+
+```ruby
+require "opentrust"
+
+client = OpenTrust::Client.new(api_key: ENV["OPENTRUST_API_KEY"]) # or just set OPENTRUST_API_KEY
+
+result = client.lookup("98765 43210")   # uses 1 check
+result.reported?       # => true / false
+result.report_count    # => 2
+result.reports.each { |r| puts "#{r.reason_code}: #{r.notes}" }
+result.notice          # keep this in front of anyone who sees the result
+result.checks_remaining
+
+client.lookup_many(%w[9876543210 9000000001])          # up to 100, all or nothing
+client.report(phone: "9876543210", reason_code: "cod_refusal", notes: "Refused 3 COD orders in March")
+client.me                                               # => { "checks_remaining" => ..., ... }
+```
+
+## Please don't block checkout on OpenTrust
+
+Results are unverified observations from individual merchants. Use them as one input, have a person review decisions that matter, and fail open if OpenTrust is unreachable:
+
+```ruby
+begin
+  result = client.lookup(order.phone)
+  flag_for_review(order) if result.reported?
+rescue OpenTrust::Error => e
+  Rails.logger.warn("OpenTrust unavailable: #{e.message}") # carry on
+end
+```
+
+Errors: `AuthenticationError` (401), `NoChecksError` (402, write to us and we'll raise your limit), `NotApprovedError` (403), `DuplicateReportError` (409), `InvalidRequestError` (422), `RateLimitError` (429), `ServerError` (5xx), `ConnectionError` (network/timeout). All inherit from `OpenTrust::Error` and carry `status` and `code`.
+
+Timeout defaults to 5 seconds (`timeout:`). Docs: https://opentrust.in/docs

data/lib/opentrust/client.rb

@@ -0,0 +1,100 @@
+require "json"
+require "net/http"
+require "uri"
+
+module OpenTrust
+  Report = Struct.new(:reason_code, :reason, :notes, :reported_at, :reporter_verified, keyword_init: true)
+
+  # The result of checking one number. Reports are unverified observations from individual merchants,
+  # not a finding about anyone. Use them as one input among others.
+  Lookup = Struct.new(:phone_last4, :report_count, :reports, :notice, :checks_remaining, keyword_init: true) do
+    def reported?
+      report_count.to_i.positive?
+    end
+  end
+
+  Receipt = Struct.new(:id, :phone_last4, keyword_init: true)
+
+  class Client
+    DEFAULT_BASE_URL = "https://opentrust.in/api/v1".freeze
+
+    # adapter: optional callable (method, url, headers, body) -> [status, body_string], mainly for tests.
+    def initialize(api_key: ENV["OPENTRUST_API_KEY"], base_url: ENV.fetch("OPENTRUST_BASE_URL", DEFAULT_BASE_URL), timeout: 5, adapter: nil)
+      raise ArgumentError, "api_key is required (or set OPENTRUST_API_KEY)" if api_key.to_s.empty?
+
+      @api_key = api_key
+      @base_url = base_url.chomp("/")
+      @timeout = timeout
+      @adapter = adapter
+    end
+
+    # Check one number. Uses one check from your allowance.
+    def lookup(phone)
+      lookup_from(request(:post, "/lookups", phone: phone))
+    end
+
+    # Check up to 100 numbers. All or nothing: if you don't have enough checks, none are used.
+    def lookup_many(phones)
+      body = request(:post, "/lookups/batch", phones: Array(phones))
+      body.fetch("results").map { |r| lookup_from(r.merge("notice" => body["notice"], "checks_remaining" => body["checks_remaining"])) }
+    end
+
+    # Share an experience with a number. Optional, and doesn't change your allowance.
+    def report(phone:, reason_code:, notes: nil)
+      body = request(:post, "/reports", { phone: phone, reason_code: reason_code, notes: notes }.compact)
+      Receipt.new(id: body["id"], phone_last4: body["phone_last4"])
+    end
+
+    # Your remaining checks and usage, as a Hash.
+    def me
+      request(:get, "/me")
+    end
+
+    private
+
+    def lookup_from(h)
+      Lookup.new(
+        phone_last4: h["phone_last4"], report_count: h["report_count"], notice: h["notice"], checks_remaining: h["checks_remaining"],
+        reports: Array(h["reports"]).map { |r| Report.new(reason_code: r["reason_code"], reason: r["reason"], notes: r["notes"], reported_at: r["reported_at"], reporter_verified: r["reporter_verified"]) }
+      )
+    end
+
+    def request(verb, path, payload = nil)
+      headers = { "Authorization" => "Bearer #{@api_key}", "Accept" => "application/json", "User-Agent" => "opentrust-ruby/#{VERSION}" }
+      headers["Content-Type"] = "application/json" if payload
+      status, text = perform(verb, "#{@base_url}#{path}", headers, payload && JSON.generate(payload))
+      body = begin JSON.parse(text.to_s) rescue {} end
+      raise_for(status, body) unless (200..299).cover?(status)
+      body
+    end
+
+    def perform(verb, url, headers, body)
+      return @adapter.call(verb, url, headers, body) if @adapter
+
+      uri = URI(url)
+      klass = verb == :get ? Net::HTTP::Get : Net::HTTP::Post
+      req = klass.new(uri, headers)
+      req.body = body if body
+      res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", open_timeout: @timeout, read_timeout: @timeout) { |http| http.request(req) }
+      [res.code.to_i, res.body]
+    rescue Timeout::Error, SystemCallError, SocketError, OpenSSL::SSL::SSLError, EOFError => e
+      raise ConnectionError.new("could not reach OpenTrust: #{e.class}: #{e.message}")
+    end
+
+    def raise_for(status, body)
+      err = body["error"].is_a?(Hash) ? body["error"] : {}
+      message = err["message"] || "OpenTrust returned HTTP #{status}"
+      klass = case status
+              when 401 then AuthenticationError
+              when 402 then NoChecksError
+              when 403 then NotApprovedError
+              when 409 then DuplicateReportError
+              when 422 then InvalidRequestError
+              when 429 then RateLimitError
+              when 500..599 then ServerError
+              else Error
+              end
+      raise klass.new(message, status: status, code: err["code"])
+    end
+  end
+end

data/lib/opentrust/errors.rb

@@ -0,0 +1,21 @@
+module OpenTrust
+  # Base class. Rescue this to handle anything that goes wrong talking to OpenTrust.
+  class Error < StandardError
+    attr_reader :status, :code
+
+    def initialize(message = nil, status: nil, code: nil)
+      super(message)
+      @status = status
+      @code = code
+    end
+  end
+
+  class ConnectionError < Error; end        # network failure or timeout
+  class AuthenticationError < Error; end    # 401: missing or invalid API key
+  class NoChecksError < Error; end          # 402: allowance used up
+  class NotApprovedError < Error; end       # 403: account not approved or suspended
+  class DuplicateReportError < Error; end   # 409: you already shared this number
+  class InvalidRequestError < Error; end    # 422: bad number, reason code or note
+  class RateLimitError < Error; end         # 429
+  class ServerError < Error; end            # 5xx
+end

data/lib/opentrust/version.rb

@@ -0,0 +1,3 @@
+module OpenTrust
+  VERSION = "0.1.1"
+end

data/lib/opentrust.rb

@@ -0,0 +1,3 @@
+require_relative "opentrust/version"
+require_relative "opentrust/errors"
+require_relative "opentrust/client"

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: opentrust
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- OpenTrust
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-09 00:00:00.000000000 Z
+dependencies: []
+description: Check mobile numbers against experiences shared by other Indian merchants,
+  and share your own. A small, dependency-free client for https://opentrust.in.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/opentrust.rb
+- lib/opentrust/client.rb
+- lib/opentrust/errors.rb
+- lib/opentrust/version.rb
+homepage: https://opentrust.in/docs
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://opentrust.in/docs
+  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: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Ruby client for the OpenTrust API
+test_files: []