opendoor-partner-sdk-server-ruby 1.1.6.beta.89.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d37317c01e3cd9592d709cb3237fed1684aa0bcd5d878257b1ccefbf0b21e675
+  data.tar.gz: '0728067630fb3ce7a0d70f6231df246e689c46e45df9396c4a4e896dbbf07272'
+SHA512:
+  metadata.gz: 8f553886988ebe99b974876a38e98dbf74bb0299386350fe8b42de3ebf888b16599f3be46f467b4b5953b7b5ea55c16a65395257e11ec38d46060d7d9364aee8
+  data.tar.gz: a7c722ac79a461f0177331b6864c6fc098b5567e87ae45488da4431ffa000fbd039eee6ed4e41366a3aac2cd69f3cebf8eea7d3b7c607c4bda798c3e8af38ae3

data/LICENSE.txt

@@ -0,0 +1,118 @@
+PROPRIETARY LICENSE — OPENDOOR PARTNER SDK (DISTRIBUTED ARTIFACTS ONLY)
+
+Copyright © 2026 Opendoor Labs. All rights reserved.
+
+1. Scope
+
+This license applies solely to the bundled, compiled, or otherwise distributable
+artifacts made available by Opendoor Labs on public package registries as part
+of the "Opendoor Partner SDK" (the "Artifacts"). "Artifacts" include, without
+limitation:
+
+- The Ruby gem "opendoor-partner-sdk-server-ruby" distributed via RubyGems.org;
+  and
+- The JavaScript/TypeScript npm packages published under the @opendoor/ scope
+  that are built from this repository (including, for example,
+  @opendoor/partner-sdk-server-js-core, @opendoor/partner-sdk-client-js-core,
+  @opendoor/partner-sdk-client-react, and @opendoor/partner-sdk-client-vue).
+
+For clarity, this license does not grant any rights to any source code, build
+scripts, or other materials that are not included in the Artifacts. All such
+materials remain proprietary and confidential to Opendoor Labs.
+
+2. Prerequisite; Partner Agreement Controls
+
+No license is granted under this notice unless you (or the entity on whose
+behalf you act) have an active, fully executed written partner agreement with
+Opendoor Labs Inc. ("Opendoor") governing your use of Opendoor's partner APIs
+(the "Partner Agreement") and you are in compliance with the Partner Agreement.
+Use of the Artifacts without an active Partner Agreement is not authorized.
+
+If there is a conflict between this license and the Partner Agreement, the
+Partner Agreement will control.
+
+3. Limited License Grant
+
+Subject to Section 2, Opendoor grants you a limited, non-exclusive,
+non-transferable, non-sublicensable, revocable license to: (a) download,
+install, copy, and use the Artifacts for internal development, testing, and
+operation; and (b) use the Artifacts solely to integrate your applications with
+Opendoor partner APIs in accordance with Opendoor's published documentation and
+the Partner Agreement.
+
+You may reproduce the Artifacts as reasonably necessary for backup, caching,
+CI/CD, and deployment, and you may distribute the Artifacts only as embedded or
+included with your application for the authorized purpose above, and not on a
+standalone basis.
+
+4. Restrictions
+
+Except as expressly permitted in Section 3 or the Partner Agreement, you may
+not (and may not permit any third party to): (a) copy, modify, translate, or
+create derivative works of the Artifacts; (b) distribute, sublicense, sell,
+lease, or otherwise make the Artifacts available to any third party on a
+standalone basis; (c) reverse engineer, decompile, or disassemble the
+Artifacts, except to the extent such restriction is prohibited by applicable
+law; (d) remove, obscure, or alter any proprietary notices in the Artifacts; or
+(e) use the Artifacts for any purpose other than the authorized integration with
+Opendoor partner APIs. No rights are granted to Opendoor Labs' trademarks,
+service marks, or logos under this license.
+
+5. Ownership
+
+The Artifacts are licensed, not sold. Opendoor retains all right, title, and
+interest in and to the Artifacts, including all intellectual property rights
+therein.
+
+6. Disclaimer
+
+THE ARTIFACTS ARE PROVIDED "AS IS" AND "AS AVAILABLE," WITHOUT WARRANTY OF ANY
+KIND, WHETHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, INCLUDING ANY IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
+NON-INFRINGEMENT.
+
+7. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT WILL OPENDOOR BE LIABLE FOR
+ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, PUNITIVE, OR EXEMPLARY
+DAMAGES, OR FOR ANY LOSS OF PROFITS, REVENUE, DATA, OR BUSINESS INTERRUPTION,
+ARISING OUT OF OR RELATED TO THE ARTIFACTS OR THIS LICENSE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGES.
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, OPENDOOR'S TOTAL LIABILITY ARISING OUT
+OF OR RELATED TO THE ARTIFACTS OR THIS LICENSE WILL NOT EXCEED THE LESSER OF
+$100 OR THE AMOUNTS PAID BY YOU TO OPENDOOR UNDER THE PARTNER AGREEMENT IN THE
+TWELVE (12) MONTHS PRECEDING THE EVENT GIVING RISE TO THE CLAIM.
+
+8. Termination
+
+This license will terminate automatically upon: (a) any breach of this license;
+(b) expiration or termination of the Partner Agreement; or (c) Opendoor's
+written notice. Upon termination, you must immediately cease all use of the
+Artifacts and destroy all copies in your possession or control, except that you
+may retain copies solely as required to comply with applicable law or bona fide
+internal record retention policies.
+
+9. Export and Sanctions Compliance
+
+You represent and warrant that you are not (and are not acting on behalf of)
+any person or entity that is the subject or target of sanctions administered or
+enforced by the United States (including the U.S. Department of the Treasury's
+Office of Foreign Assets Control), and that you will not use, export,
+re-export, transfer, or release the Artifacts in violation of applicable export
+control or sanctions laws and regulations.
+
+10. Governing Law; Venue
+
+This license is governed by and construed in accordance with the laws of the
+State of California, without regard to its conflict of law principles. Subject
+to any dispute resolution provisions in the Partner Agreement, any dispute
+arising out of or relating to the Artifacts or this license will be brought
+exclusively in the state or federal courts located in California, and each
+party consents to personal jurisdiction and venue there.
+
+11. Severability
+
+If any provision of this license is held to be invalid or unenforceable, that
+provision will be enforced to the maximum extent permissible, and the remaining
+provisions will remain in full force and effect.

data/README.md

@@ -0,0 +1,78 @@
+# Opendoor Partner Server Ruby SDK
+
+Standalone Ruby port of `packages/server-js-core`.
+
+## Installation
+
+```ruby
+gem "opendoor-partner-sdk-server-ruby"
+```
+
+## Usage
+
+```ruby
+require "opendoor/partner_sdk"
+
+client = Opendoor::PartnerSdk::Client.new(
+  api_key: ENV.fetch("OPENDOOR_API_KEY"),
+  environment: :staging
+)
+
+offer = client.create_offer(
+  data: {
+    address: {
+      street1: "123 Main St",
+      city: "Austin",
+      state: "TX",
+      postalCode: "78701"
+    }
+  }
+)
+```
+
+The `timeout:` keyword accepts **milliseconds** (default `30_000`), matching `@opendoor/partner-sdk-server-js-core`.
+
+## API Methods
+
+- `get_address_suggestions(query:)`
+- `create_offer(data:)`
+- `update_offer(offer_id:, data:)`
+- `get_offer(offer_id:)`
+- `get_offer_with_sell_direct_pricing(offer_id:)`
+- `check_address_unit(address:)`
+- `get_address_details(address:, tracking_id: nil)`
+- `get_homebuilders`
+- `get_assessment_slots(offer_id:)`
+- `get_home_detail(opendoor_offer_request_id:)`
+
+## Errors
+
+- `Opendoor::PartnerSdk::ValidationError` for local input validation
+- `Opendoor::PartnerSdk::ApiError` for network/API failures, GraphQL errors, and invalid JSON (`code: "PARSE_ERROR"`)
+
+## License
+
+The Gem is **proprietary** to Opendoor Labs. Opendoor distributes it only as the **bundled package** on RubyGems.org under the terms in [`LICENSE.txt`](LICENSE.txt). Development sources and the broader codebase are **not** offered under an open-source license. Use is limited to integrating with Opendoor partner APIs as described in Opendoor documentation.
+
+## Publishing (maintainers)
+
+CI builds and tests this gem on every PR (`ci.yml`). Releases mirror the JS packages:
+
+| Trigger | Workflow | What gets published |
+|--------|----------|----------------------|
+| GitHub **Release** published (semver tag, e.g. `v1.2.3`) | [`publish.yml`](../../.github/workflows/publish.yml) — job `publish-rubygem` | Release gem `opendoor-partner-sdk-server-ruby` at that version |
+| Push to **`main`** | [`publish-next.yml`](../../.github/workflows/publish-next.yml) — job `publish-rubygem-next` | Prerelease gem `X.Y.Z.beta.{run}.{attempt}` |
+
+### GitHub Actions secrets
+
+| Secret | Required for | Where to get it |
+|--------|----------------|-----------------|
+| **`RUBYGEMS_API_KEY`** | `gem push` to rubygems.org | [rubygems.org → Edit profile → API access](https://rubygems.org/profile/edit). Create a key with permission to **push** gems for this gem name. |
+
+Add the secret in the repo: **Settings → Secrets and variables → Actions → New repository secret**. Name must be exactly `RUBYGEMS_API_KEY`.
+
+The npm workflows continue to use **`NPM_TOKEN`** for JS packages only; Ruby publishing does not use it.
+
+### First-time gem name
+
+The owning RubyGems account must be authorized to publish `opendoor-partner-sdk-server-ruby` (create the gem once or accept ownership transfer per RubyGems policy).

data/lib/opendoor/partner_sdk/answer_key_mapping.rb

@@ -0,0 +1,187 @@
+module Opendoor
+  module PartnerSdk
+    module AnswerKeyMapping
+      DOT_TO_CAMEL = {
+        "home.bedrooms" => "homeBedrooms",
+        "home.bathrooms.full" => "homeBathroomsFull",
+        "home.bathrooms.half" => "homeBathroomsPartial",
+        "home.above_grade_sq_ft" => "homeAboveGradeSqFt",
+        "home.dwelling_type" => "homeDwellingType",
+        "home.year_built" => "homeYearBuilt",
+        "home.exterior_stories" => "homeExteriorStories",
+        "home.entry_type" => "homeEntryType",
+        "home.covered_parking_type" => "homeCoveredParkingType",
+        "home.garage_spaces" => "homeGarageSpaces",
+        "home.carport_spaces" => "homeCarportSpaces",
+        "home.pool_type" => "homePoolType",
+        "home.has_basement" => "homeHasBasement",
+        "home.basement_finished_sq_ft" => "homeBasementFinishedSqFt",
+        "home.basement_unfinished_sq_ft" => "homeBasementUnfinishedSqFt",
+        "home.kitchen_counter_type" => "homeKitchenCounterType",
+        "home.hoa" => "homeHoa",
+        "home.hoa_fees" => "homeHoaFees",
+        "home.has_upgrades" => "homeHasUpgrades",
+        "home.kitchen_seller_score" => "homeKitchenCondition",
+        "home.bathroom_seller_score" => "homeBathroomCondition",
+        "home.living_room_seller_score" => "homeLivingRoomCondition",
+        "home.exterior_seller_score" => "homeExteriorCondition",
+        "home.eligibility_criteria.leased_solar_panels" => "homeEligibilityCriteriaLeasedSolarPanels",
+        "home.eligibility_criteria.known_foundation_issues" => "homeEligibilityCriteriaKnownFoundationIssues",
+        "home.eligibility_criteria.fire_damage" => "homeEligibilityCriteriaFireDamage",
+        "home.eligibility_criteria.well_water" => "homeEligibilityCriteriaWellWater",
+        "home.eligibility_criteria.septic" => "homeEligibilityCriteriaSeptic",
+        "home.eligibility_criteria.asbestos_siding" => "homeEligibilityCriteriaAsbestosSiding",
+        "home.eligibility_criteria.livestock" => "homeEligibilityCriteriaLivestock",
+        "home.eligibility_criteria.mobile_manufactured_home" => "homeEligibilityCriteriaMobileManufacturedHome",
+        "seller.full_name" => "sellerFullName",
+        "seller.email" => "sellerEmail",
+        "seller.phone_number" => "sellerPhoneNumber",
+        "seller.sms_opt_in" => "sellerSmsOptIn",
+        "seller.relation_to_owner" => "sellerRelationToOwner",
+        "seller.relation_to_owner.other" => "sellerRelationToOwnerOther",
+        "seller.sale_timeline" => "sellerSaleTimeline",
+        "seller.working_with_home_builder" => "sellerWorkingWithHomeBuilder",
+        "seller.home_builder" => "sellerHomeBuilder",
+        "seller.home_builder_email" => "sellerHomeBuilderEmail",
+        "seller.home_builder_community" => "sellerHomeBuilderCommunity"
+      }.freeze
+
+      SKIP_KEYS = ["offerId"].freeze
+
+      NUMERIC_KEYS = [
+        "home.bedrooms",
+        "home.bathrooms.full",
+        "home.bathrooms.half",
+        "home.above_grade_sq_ft",
+        "home.exterior_stories",
+        "home.year_built",
+        "home.garage_spaces",
+        "home.carport_spaces",
+        "home.hoa_fees",
+        "home.basement_finished_sq_ft",
+        "home.basement_unfinished_sq_ft"
+      ].freeze
+
+      EXPERIMENTAL_KEYS = [
+        "home.mortgage_balance",
+        "home.lot_sq_ft",
+        "home.upper_level_sq_ft",
+        "home.basement_sq_ft"
+      ].freeze
+
+      POOL_TYPE_NORMALIZE = {
+        "none" => "no_pool",
+        "community" => "community_pool"
+      }.freeze
+
+      module_function
+
+      def transform_answers_to_offer_input(answers)
+        offer_input = {}
+        experimental = []
+
+        answers.each do |raw_key, raw_value|
+          key = raw_key.to_s
+          next if raw_value.nil? || SKIP_KEYS.include?(key)
+
+          value = normalize_pool_type(key, raw_value)
+
+          if key == "home.hoa_type"
+            values = value.is_a?(Array) ? value : [value]
+            next if values.length == 1 && values.first == "none"
+
+            offer_input["homeHoaTypeAgeRestrictedCommunity"] = values.include?("age_restricted_community")
+            offer_input["homeHoaTypeGatedCommunity"] = values.include?("gated_community")
+            next
+          end
+
+          if key == "home.eligibility_criteria"
+            map_eligibility_criteria(offer_input, value)
+            next
+          end
+
+          if key == "home.hoa_type.guarded_gated_community"
+            offer_input["homeHoaTypeGuardedGatedCommunity"] = value == "has_guard"
+            next
+          end
+
+          camel_key = DOT_TO_CAMEL[key]
+          if camel_key
+            offer_input[camel_key] = coerce_mapped_value(key, value)
+          elsif experimental_key?(key)
+            experimental_value = to_experimental_entry(key, value)
+            experimental << experimental_value if experimental_value
+          else
+            offer_input[key] = value
+          end
+        end
+
+        offer_input["experimental"] = experimental unless experimental.empty?
+        offer_input
+      end
+
+      def normalize_pool_type(key, value)
+        return value unless key == "home.pool_type"
+        return value unless value.is_a?(String)
+
+        POOL_TYPE_NORMALIZE.fetch(value, value)
+      end
+
+      def map_eligibility_criteria(offer_input, value)
+        values = value.is_a?(Array) ? value : []
+        criteria_map = {
+          "leased_solar_panels" => "homeEligibilityCriteriaLeasedSolarPanels",
+          "known_foundation_issues" => "homeEligibilityCriteriaKnownFoundationIssues",
+          "fire_damage" => "homeEligibilityCriteriaFireDamage",
+          "well_water" => "homeEligibilityCriteriaWellWater",
+          "septic" => "homeEligibilityCriteriaSeptic",
+          "asbestos_siding" => "homeEligibilityCriteriaAsbestosSiding",
+          "livestock" => "homeEligibilityCriteriaLivestock",
+          "mobile_manufactured_home" => "homeEligibilityCriteriaMobileManufacturedHome",
+          "unique_ownership_structure" => "homeEligibilityCriteriaUniqueOwnershipStructure",
+          "below_market_rate_ownership" => "homeEligibilityCriteriaBelowMarketRateOwnership",
+          "rent_controlled_tenant_occupied" => "homeEligibilityCriteriaRentControlledTenantOccupied"
+        }
+
+        criteria_map.each do |criteria_value, graphql_field|
+          offer_input[graphql_field] = values.include?(criteria_value)
+        end
+      end
+
+      def coerce_mapped_value(key, value)
+        return true if value == "yes"
+        return false if value == "no"
+        return true if value == "true"
+        return false if value == "false"
+
+        if value.is_a?(String) && !value.empty? && NUMERIC_KEYS.include?(key) && numeric_string?(value)
+          return value.include?(".") ? value.to_f : value.to_i
+        end
+
+        value
+      end
+
+      def numeric_string?(value)
+        !!Float(value)
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      def experimental_key?(key)
+        key.start_with?("home.condition.") ||
+          key.start_with?("home.features.") ||
+          EXPERIMENTAL_KEYS.include?(key)
+      end
+
+      def to_experimental_entry(key, value)
+        if value.is_a?(Array)
+          { "questionKey" => key, "stringValues" => value }
+        elsif value.is_a?(Numeric)
+          { "questionKey" => key, "doubleValue" => value }
+        elsif value == true || value == false
+          { "questionKey" => key, "stringValues" => [value ? "true" : "false"] }
+        end
+      end
+    end
+  end
+end

data/lib/opendoor/partner_sdk/client.rb

@@ -0,0 +1,412 @@
+require "json"
+require "net/http"
+require "securerandom"
+require "set"
+require "uri"
+
+module Opendoor
+  module PartnerSdk
+    class Client
+      VALID_OFFER_INPUT_FIELDS = %w[
+        sellerEmail sellerFullName sellerPhoneNumber sellerRelationToOwner sellerWorkingWithHomeBuilder
+        sellerSaleTimeline homeDwellingType homeBedrooms homeBathroomsFull homeBathroomsPartial homeYearBuilt
+        homeExteriorStories homeAboveGradeSqFt homeCoveredParkingType homeGarageSpaces homeCarportSpaces
+        homePoolType homeHasBasement homeBasementFinishedSqFt homeBasementUnfinishedSqFt homeKitchenCounterType
+        homeHoa homeHoaTypeAgeRestrictedCommunity homeHoaTypeGatedCommunity homeHoaTypeGuardedGatedCommunity
+        homeEntryType homeKitchenCondition homeBathroomCondition homeLivingRoomCondition homeExteriorCondition
+        homeEligibilityCriteriaLeasedSolarPanels homeEligibilityCriteriaKnownFoundationIssues homeEligibilityCriteriaFireDamage
+        homeEligibilityCriteriaWellWater homeEligibilityCriteriaSeptic homeEligibilityCriteriaAsbestosSiding
+        homeEligibilityCriteriaLivestock homeEligibilityCriteriaMobileManufacturedHome homeEligibilityCriteriaUniqueOwnershipStructure
+        homeEligibilityCriteriaBelowMarketRateOwnership homeEligibilityCriteriaRentControlledTenantOccupied homeHoaFees
+        homeHasUpgrades sellerSmsOptIn correlationId experimental
+      ].to_set.freeze
+
+      ENUM_FIELDS = %w[
+        homeDwellingType homeCoveredParkingType homePoolType homeEntryType homeKitchenCounterType
+        homeKitchenCondition homeBathroomCondition homeLivingRoomCondition homeExteriorCondition sellerRelationToOwner
+      ].to_set.freeze
+
+      ENDPOINTS = {
+        production: {
+          api_endpoint: "https://partner.opendoor.com/api/graphql",
+          address_endpoint: "https://www.opendoor.com",
+          gateway_endpoint: "https://graphql.opendoor.com/api/graphql"
+        },
+        staging: {
+          api_endpoint: "https://partner.simplersell.com/api/graphql",
+          address_endpoint: "https://demo.simplersell.com",
+          gateway_endpoint: "https://graphql.simplersell.com/api/graphql"
+        }
+      }.freeze
+
+      # Matches server-js-core: request timeout in milliseconds (see OpendoorClientConfig.timeout).
+      DEFAULT_TIMEOUT_MS = 30_000
+
+      def initialize(api_key:, environment: :staging, timeout: DEFAULT_TIMEOUT_MS, debug: false, api_endpoint: nil, address_endpoint: nil, gateway_endpoint: nil)
+        raise ValidationError.new("apiKey is required", "apiKey") if blank?(api_key)
+
+        env = environment.to_sym
+        endpoints = ENDPOINTS.fetch(env)
+
+        @api_key = api_key
+        @api_endpoint = api_endpoint || endpoints[:api_endpoint]
+        @address_endpoint = address_endpoint || endpoints[:address_endpoint]
+        @gateway_endpoint = gateway_endpoint || endpoints[:gateway_endpoint]
+        @timeout_ms = timeout
+        # Net::HTTP expects seconds (fractional allowed); keep parity with JS ms default.
+        @timeout_seconds = [@timeout_ms / 1000.0, 0.001].max
+        @debug = debug
+      end
+
+      def get_address_suggestions(query:)
+        return { addresses: [] } if blank?(query)
+
+        session_token = SecureRandom.uuid
+        params = URI.encode_www_form(query: query, sessionToken: session_token)
+        url = "#{@address_endpoint}/_address-input/autocomplete?#{params}"
+        log("REST GET -> #{@address_endpoint}/_address-input/autocomplete")
+
+        response = fetch_with_timeout(url, method: :get, headers: { "Content-Type" => "application/json" })
+        ensure_ok!(response, "Autocomplete request failed", "NETWORK_ERROR")
+
+        raw = parse_json_response(response.body, http_status: response.code.to_i)
+        predictions = raw.fetch("predictions", [])
+        addresses = predictions.map do |prediction|
+          begin
+            resolve_prediction(prediction, session_token)
+          rescue StandardError
+            nil
+          end
+        end.compact
+
+        { addresses: addresses }
+      end
+
+      def create_offer(data:)
+        Validators.validate_create_offer_request(data)
+        address = get(data, :address)
+
+        result = graphql(
+          query: Graphql::OFFER_REQUEST_CREATE,
+          variables: {
+            offerRequestCreateInput: {
+              address: normalize_address(address),
+              saleAssociateEmail: get(data, :sales_associate_email, :salesAssociateEmail),
+              saleAssociateName: get(data, :sales_associate_name, :salesAssociateName)
+            }.compact
+          }
+        )
+
+        symbolize_keys(result.fetch("offerRequestCreate").fetch("offerRequest"))
+      end
+
+      def update_offer(offer_id:, data:)
+        Validators.validate_update_offer_request(offer_id, data)
+        transformed = AnswerKeyMapping.transform_answers_to_offer_input(stringify_keys(data))
+        offer_input = {}
+
+        transformed.each do |key, value|
+          next if value.nil?
+          next unless VALID_OFFER_INPUT_FIELDS.include?(key)
+
+          offer_input[key] = if value.is_a?(String) && ENUM_FIELDS.include?(key)
+                               value.upcase
+                             else
+                               value
+                             end
+        end
+
+        result = graphql(
+          query: Graphql::OFFER_REQUEST_UPDATE,
+          variables: {
+            offerRequestUpdateInput: {
+              opendoorOfferRequestId: offer_id,
+              offerInput: offer_input
+            }
+          }
+        )
+
+        symbolize_keys(result.fetch("offerRequestUpdate").fetch("offerRequest"))
+      end
+
+      def get_offer(offer_id:)
+        raise ValidationError.new("offerId is required", "offerId") if blank?(offer_id)
+
+        result = graphql(
+          query: Graphql::OFFER_REQUEST_QUERY,
+          variables: { opendoorOfferRequestId: offer_id }
+        )
+        symbolize_keys(result.fetch("offerRequest"))
+      end
+
+      def get_offer_with_sell_direct_pricing(offer_id:)
+        raise ValidationError.new("offerId is required", "offerId") if blank?(offer_id)
+
+        result = graphql(
+          query: Graphql::OFFER_REQUEST_WITH_SELL_DIRECT_PRICING,
+          variables: { opendoorOfferRequestId: offer_id }
+        )
+        symbolize_keys(result.fetch("offerRequestWithSellDirectPricing"))
+      end
+
+      def check_address_unit(address:)
+        raise ValidationError.new("street1 is required", "street1") if blank?(get(address, :street1))
+
+        result = graphql(
+          query: Graphql::ADDRESS_UNIT_CHECK,
+          variables: { address: normalize_address(address) }
+        )
+        symbolize_keys(result.fetch("addressUnitCheck"))
+      end
+
+      def get_address_details(address:, tracking_id: nil)
+        raise ValidationError.new("street1 is required", "street1") if blank?(get(address, :street1))
+
+        variables = { address: normalize_address(address) }
+        variables[:trackingId] = tracking_id if tracking_id
+
+        result = graphql(query: Graphql::ADDRESS_DETAILS_QUERY, variables: variables)
+        symbolize_keys(result.fetch("address"))
+      end
+
+      def get_homebuilders
+        log("GraphQL (gateway) -> #{@gateway_endpoint}")
+        response = fetch_with_timeout(
+          @gateway_endpoint,
+          method: :post,
+          headers: {
+            "Content-Type" => "application/json",
+            "apollographql-client-name" => "partner-sdk",
+            "apollographql-client-version" => "1.0"
+          },
+          body: JSON.generate(
+            query: Graphql::LIST_PARTNERS_QUERY,
+            variables: { partnershipType: "HOME_BUILDER" }
+          )
+        )
+
+        ensure_ok!(response, "Homebuilders request failed", "GRAPHQL_ERROR")
+        json = parse_json_response(response.body, http_status: response.code.to_i)
+        ensure_graphql_data!(json)
+
+        partners = json.dig("data", "partnership", "listPartners", "partners")
+        unless partners.is_a?(Array)
+          raise ApiError.new("GraphQL response missing partnership.listPartners.partners", "GRAPHQL_ERROR", 200)
+        end
+
+        {
+          homebuilders: partners.map do |partner|
+            {
+              identifier: partner["identifier"],
+              displayName: partner["displayName"]
+            }
+          end
+        }
+      end
+
+      def get_assessment_slots(offer_id:)
+        raise ValidationError.new("offerId is required", "offerId") if blank?(offer_id)
+
+        api_base = graphql_api_origin
+        url = "#{api_base}/v2/exterior_assessment_slots"
+        log("REST POST -> #{url}")
+
+        response = fetch_with_timeout(
+          url,
+          method: :post,
+          headers: {
+            "Content-Type" => "application/json",
+            "Authorization" => "Basic #{@api_key}"
+          },
+          body: JSON.generate(
+            partnerId: @api_key,
+            sellerInputUuid: offer_id,
+            calendarType: "DILIGENCE_VISIT"
+          )
+        )
+        ensure_ok!(response, "Assessment slots request failed", "NETWORK_ERROR")
+        raw = parse_json_response(response.body, http_status: response.code.to_i)
+
+        unless raw["success"]
+          raise ApiError.new(raw["error"] || "Assessment slots request failed", "API_ERROR", 200)
+        end
+
+        {
+          currentInspectionTime: raw["currentInspectionTime"],
+          availableSlots: raw["availableSlots"] || [],
+          isSlotBased: raw["isSlotBased"] || false,
+          visitId: raw["visitId"] || "",
+          timezone: raw["timezone"] || "UTC"
+        }
+      end
+
+      def get_home_detail(opendoor_offer_request_id:)
+        raise ValidationError.new("opendoorOfferRequestId is required", "opendoorOfferRequestId") if blank?(opendoor_offer_request_id)
+
+        data = graphql(
+          query: Graphql::SELLER_INPUT_PREFILLS_QUERY,
+          variables: { sellerInputUuid: opendoor_offer_request_id }
+        )
+
+        seller_prefills = data["sellerInputPrefills"]
+        raise ApiError.new("Home detail not found", "NOT_FOUND", 404) if seller_prefills.nil?
+
+        { answerPrefills: seller_prefills["answerPrefills"] || {} }
+      end
+
+      private
+
+      def resolve_prediction(prediction, session_token)
+        if prediction["street"] && prediction["city"] && prediction["state"] && prediction["postalCode"]
+          return {
+            street1: prediction["street"],
+            street2: prediction["unitInfo"],
+            city: prediction["city"],
+            state: prediction["state"],
+            postalCode: prediction["postalCode"]
+          }.compact
+        end
+
+        place_id = prediction["place_id"]
+        raise "Cannot resolve prediction" if blank?(place_id)
+
+        get_place_details(place_id, session_token)
+      end
+
+      def get_place_details(place_id, session_token)
+        params = URI.encode_www_form(placeId: place_id, sessionToken: session_token)
+        url = "#{@address_endpoint}/_address-input/place?#{params}"
+        response = fetch_with_timeout(url, method: :get, headers: { "Content-Type" => "application/json" })
+        ensure_ok!(response, "Place details request failed", "NETWORK_ERROR")
+        raw = parse_json_response(response.body, http_status: response.code.to_i)
+
+        {
+          street1: raw["street1"].to_s.strip,
+          street2: raw["street2"],
+          city: raw["city"],
+          state: raw["state"],
+          postalCode: raw["postal_code"]
+        }.compact
+      end
+
+      def graphql(query:, variables:)
+        response = fetch_with_timeout(
+          @api_endpoint,
+          method: :post,
+          headers: {
+            "Content-Type" => "application/json",
+            "Authorization" => "Basic #{@api_key}"
+          },
+          body: JSON.generate(query: query, variables: variables)
+        )
+        ensure_ok!(response, "GraphQL request failed", "GRAPHQL_ERROR")
+
+        json = parse_json_response(response.body, http_status: response.code.to_i)
+        ensure_graphql_data!(json)
+        json.fetch("data")
+      end
+
+      def ensure_graphql_data!(json)
+        if json["errors"].is_a?(Array) && !json["errors"].empty?
+          message = json["errors"].map { |error| error["message"] }.join(", ")
+          raise ApiError.new("GraphQL errors: #{message}", "GRAPHQL_ERROR", 200, json["errors"])
+        end
+
+        raise ApiError.new("GraphQL response missing data", "GRAPHQL_ERROR", 200) if json["data"].nil?
+      end
+
+      def ensure_ok!(response, prefix, code)
+        status = response.code.to_i
+        return if status >= 200 && status < 300
+
+        raise ApiError.new("#{prefix}: #{status} #{response.message}", code, status)
+      end
+
+      def fetch_with_timeout(url, method:, headers:, body: nil)
+        uri = URI.parse(url)
+        request_class = method == :post ? Net::HTTP::Post : Net::HTTP::Get
+        request = request_class.new(uri.request_uri)
+        headers.each { |k, v| request[k] = v }
+        request.body = body if body
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = @timeout_seconds
+        http.read_timeout = @timeout_seconds
+        http.request(request)
+      rescue Net::OpenTimeout, Net::ReadTimeout
+        raise ApiError.new("Request timed out after #{@timeout_ms}ms", "TIMEOUT", 0)
+      rescue SocketError, Errno::ECONNREFUSED, IOError => e
+        raise ApiError.new("Network error: #{e.message}", "NETWORK_ERROR", 0)
+      end
+
+      def normalize_address(address)
+        {
+          street1: get(address, :street1),
+          street2: get(address, :street2),
+          city: get(address, :city),
+          state: get(address, :state),
+          postalCode: get(address, :postal_code, :postalCode)
+        }.compact
+      end
+
+      def stringify_keys(value)
+        if value.is_a?(Hash)
+          value.each_with_object({}) do |(k, v), h|
+            h[k.to_s] = stringify_keys(v)
+          end
+        elsif value.is_a?(Array)
+          value.map { |v| stringify_keys(v) }
+        else
+          value
+        end
+      end
+
+      def symbolize_keys(value)
+        if value.is_a?(Hash)
+          value.each_with_object({}) do |(k, v), h|
+            h[k.to_sym] = symbolize_keys(v)
+          end
+        elsif value.is_a?(Array)
+          value.map { |v| symbolize_keys(v) }
+        else
+          value
+        end
+      end
+
+      def get(hash, *keys)
+        return nil unless hash.is_a?(Hash)
+
+        keys.each do |key|
+          return hash[key] if hash.key?(key)
+          return hash[key.to_s] if hash.key?(key.to_s)
+        end
+        nil
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      # Same-origin base as JS `new URL(apiEndpoint).origin` (includes non-default port).
+      def graphql_api_origin
+        uri = URI.parse(@api_endpoint)
+        if uri.respond_to?(:origin) && !uri.origin.nil?
+          uri.origin
+        else
+          "#{uri.scheme}://#{uri.host}#{uri.port && ![80, 443].include?(uri.port) ? ":#{uri.port}" : ""}"
+        end
+      end
+
+      def parse_json_response(body, http_status:)
+        JSON.parse(body.to_s)
+      rescue JSON::ParserError => e
+        raise ApiError.new("Invalid JSON response: #{e.message}", "PARSE_ERROR", http_status)
+      end
+
+      def log(message)
+        puts("[OpendoorClient] #{message}") if @debug
+      end
+    end
+  end
+end

data/lib/opendoor/partner_sdk/errors.rb

@@ -0,0 +1,24 @@
+module Opendoor
+  module PartnerSdk
+    class ValidationError < StandardError
+      attr_reader :code, :field
+
+      def initialize(message, field = nil)
+        super(message)
+        @code = "VALIDATION_ERROR"
+        @field = field
+      end
+    end
+
+    class ApiError < StandardError
+      attr_reader :code, :status_code, :graphql_errors
+
+      def initialize(message, code, status_code, graphql_errors = nil)
+        super(message)
+        @code = code
+        @status_code = status_code
+        @graphql_errors = graphql_errors
+      end
+    end
+  end
+end

data/lib/opendoor/partner_sdk/graphql/mutations.rb

@@ -0,0 +1,37 @@
+module Opendoor
+  module PartnerSdk
+    module Graphql
+      OFFER_REQUEST_CREATE = <<~GRAPHQL.freeze
+        mutation OfferRequestCreate($offerRequestCreateInput: OfferRequestCreateInput!) {
+          offerRequestCreate(params: $offerRequestCreateInput) {
+            offerRequest {
+              opendoorOfferRequestId
+              offerStatus
+              denialInfo {
+                deniedAt
+                code
+                explanation
+              }
+            }
+          }
+        }
+      GRAPHQL
+
+      OFFER_REQUEST_UPDATE = <<~GRAPHQL.freeze
+        mutation OfferRequestUpdate($offerRequestUpdateInput: OfferRequestUpdateInput!) {
+          offerRequestUpdate(params: $offerRequestUpdateInput) {
+            offerRequest {
+              opendoorOfferRequestId
+              offerStatus
+              denialInfo {
+                deniedAt
+                code
+                explanation
+              }
+            }
+          }
+        }
+      GRAPHQL
+    end
+  end
+end

data/lib/opendoor/partner_sdk/graphql/queries.rb

@@ -0,0 +1,120 @@
+module Opendoor
+  module PartnerSdk
+    module Graphql
+      OFFER_REQUEST_QUERY = <<~GRAPHQL.freeze
+        query OfferRequest($opendoorOfferRequestId: String!) {
+          offerRequest(opendoorOfferRequestId: $opendoorOfferRequestId) {
+            opendoorOfferRequestId
+            offerStatus
+            denialInfo {
+              deniedAt
+              code
+              explanation
+            }
+            offerData {
+              headlinePriceCents
+              headlineValuationRangeStart
+              headlineValuationRangeEnd
+              feeCostCents
+              feeCostPercent
+              estimatedClosingCostCents
+              estimatedClosingCostPercent
+              repairCostCents
+              url
+              authenticatedDashboardUrl
+              offerSource
+              sentAt
+              expirationAt
+              expirationAtDisplayDate
+              underwritingCompletedAt
+              underwritingState
+              enteredContractAt
+              coeDate
+              closedAt
+              withdrawnAt
+              priceAlert
+            }
+            handoverAt
+          }
+        }
+      GRAPHQL
+
+      OFFER_REQUEST_WITH_SELL_DIRECT_PRICING = <<~GRAPHQL.freeze
+        query OfferRequestWithSellDirectPricing($opendoorOfferRequestId: String!) {
+          offerRequestWithSellDirectPricing(opendoorOfferRequestId: $opendoorOfferRequestId) {
+            opendoorOfferRequestId
+            offerStatus
+            denialInfo {
+              deniedAt
+              code
+              explanation
+            }
+            offerData {
+              netProceeds
+              sentAt
+              expirationAt
+              expirationAtDisplayDate
+              mortgageBalance
+              sellerName
+              sellerEmail
+              headlinePriceCents
+              opendoorFeeCents
+              repairCostCents
+              closingCostsCents
+            }
+          }
+        }
+      GRAPHQL
+
+      ADDRESS_UNIT_CHECK = <<~GRAPHQL.freeze
+        query AddressUnitCheck($address: AddressInput!) {
+          addressUnitCheck(address: $address) {
+            requiresUnitNumber
+          }
+        }
+      GRAPHQL
+
+      LIST_PARTNERS_QUERY = <<~GRAPHQL.freeze
+        query ListPartnersQuery($partnershipType: OdProtosPartnershipData_PartnershipType!) {
+          partnership {
+            listPartners(input: { partnershipType: $partnershipType }) {
+              partners {
+                identifier
+                displayName
+              }
+            }
+          }
+        }
+      GRAPHQL
+
+      ADDRESS_DETAILS_QUERY = <<~GRAPHQL.freeze
+        query Address($address: AddressInput!, $trackingId: String) {
+          address(address: $address) {
+            products {
+              homeSell {
+                isEligible
+                denialCode
+                denialExplanation
+                valueEstimate {
+                  lower
+                  upper
+                }
+                referral(trackingId: $trackingId) {
+                  url
+                }
+              }
+            }
+          }
+        }
+      GRAPHQL
+
+      SELLER_INPUT_PREFILLS_QUERY = <<~GRAPHQL.freeze
+        query SellerInputPrefills($sellerInputUuid: String!) {
+          sellerInputPrefills(sellerInputUuid: $sellerInputUuid) {
+            answerPrefills
+          }
+        }
+      GRAPHQL
+    end
+  end
+end

data/lib/opendoor/partner_sdk/validators.rb

@@ -0,0 +1,55 @@
+module Opendoor
+  module PartnerSdk
+    module Validators
+      module_function
+
+      def validate_address(address)
+        raise ValidationError.new("street1 is required", "address.street1") if blank?(get(address, :street1))
+        raise ValidationError.new("city is required", "address.city") if blank?(get(address, :city))
+        raise ValidationError.new("state is required", "address.state") if blank?(get(address, :state))
+        raise ValidationError.new("postalCode is required", "address.postalCode") if blank?(get(address, :postal_code, :postalCode))
+      end
+
+      def validate_create_offer_request(data)
+        unless data.is_a?(Hash)
+          raise ValidationError.new("create data must be a Hash", "data")
+        end
+
+        address = get(data, :address)
+        raise ValidationError.new("address is required", "address") if address.nil?
+        raise ValidationError.new("address must be a Hash", "address") unless address.is_a?(Hash)
+
+        validate_address(address)
+      end
+
+      def validate_update_offer_request(offer_id, data)
+        raise ValidationError.new("offerId is required", "offerId") if blank?(offer_id)
+        unless data.is_a?(Hash)
+          raise ValidationError.new("update data must be a Hash", "data")
+        end
+        raise ValidationError.new(
+          "At least one OfferInput field must be provided",
+          "offerInput"
+        ) if data.empty?
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      def get(hash, *keys)
+        return nil unless hash.is_a?(Hash)
+
+        keys.each do |key|
+          [key, key.to_s].uniq.each do |k|
+            next unless hash.key?(k)
+
+            v = hash[k]
+            return v unless v.nil?
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/opendoor/partner_sdk/version.rb

@@ -0,0 +1,5 @@
+module Opendoor
+  module PartnerSdk
+    VERSION = "1.1.6.beta.89.1"
+  end
+end

data/lib/opendoor/partner_sdk.rb

@@ -0,0 +1,12 @@
+require_relative "partner_sdk/version"
+require_relative "partner_sdk/errors"
+require_relative "partner_sdk/validators"
+require_relative "partner_sdk/answer_key_mapping"
+require_relative "partner_sdk/graphql/queries"
+require_relative "partner_sdk/graphql/mutations"
+require_relative "partner_sdk/client"
+
+module Opendoor
+  module PartnerSdk
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: opendoor-partner-sdk-server-ruby
+version: !ruby/object:Gem::Version
+  version: 1.1.6.beta.89.1
+platform: ruby
+authors:
+- Opendoor
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.22'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+description: Ruby SDK for partner backend integrations with Opendoor APIs. Distributed
+  as a packaged gem only; see LICENSE.txt. Source maintained by Opendoor Labs is proprietary.
+email:
+- partnerships@opendoor.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/opendoor/partner_sdk.rb
+- lib/opendoor/partner_sdk/answer_key_mapping.rb
+- lib/opendoor/partner_sdk/client.rb
+- lib/opendoor/partner_sdk/errors.rb
+- lib/opendoor/partner_sdk/graphql/mutations.rb
+- lib/opendoor/partner_sdk/graphql/queries.rb
+- lib/opendoor/partner_sdk/validators.rb
+- lib/opendoor/partner_sdk/version.rb
+homepage: https://partner-sdk.opendoor.com/
+licenses:
+- NONE
+metadata:
+  homepage_uri: https://partner-sdk.opendoor.com/
+  documentation_uri: https://partner-sdk.opendoor.com/
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Server-side Ruby SDK for Opendoor partner integrations
+test_files: []