kalshi 0.1.0

data/lib/kalshi/api_client.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    # Base class for API client wrappers that automatically configure URL prefixes
+    #
+    # @example Using ApiClient with a Search namespace
+    #   # For Rubyists::Kalshi::Search::Client, the prefix will be "search"
+    #   class Search::Client < ApiClient
+    #     # API calls will automatically use /search/ prefix
+    #   end
+    #
+    # @example Overriding the automatic prefix
+    #   class CustomClient < ApiClient
+    #     self.prefix = 'custom_api'
+    #   end
+    class ApiClient
+      attr_reader :client
+
+      # Automatically extract the URL prefix from the module hierarchy
+      #
+      # The prefix is derived by taking the second-to-last component of the
+      # fully qualified class name and converting it to lowercase. For example:
+      #   - Rubyists::Kalshi::Search::Client => "search"
+      #   - Rubyists::Kalshi::Market::Client => "market"
+      #
+      # @return [String] the URL prefix for API calls
+      def self.prefix
+        @prefix ||= to_s.split('::')[-2].downcase
+      end
+
+      # Set a custom URL prefix for API calls, for overriding the default behavior
+      def self.prefix=(value) # rubocop:disable Style/TrivialAccessors
+        @prefix = value
+      end
+
+      # Initialize the ApiClient with a given client instance
+      #
+      # @param client [Rubyists::Kalshi::Client] the client instance to wrap
+      #
+      # @return [void]
+      def initialize(client)
+        @client = client
+        client.prefix = self.class.prefix
+      end
+    end
+  end
+end

data/lib/kalshi/client.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'httpx'
+require 'json'
+require 'uri'
+
+module Rubyists
+  module Kalshi
+    # HTTP Client for Kalshi API
+    class Client
+      include SemanticLogger::Loggable
+
+      attr_reader :http, :base_url
+      attr_accessor :prefix
+
+      def initialize(base_url: Kalshi.config.base_url)
+        @base_url = base_url
+        @http = HTTPX.plugin(:persistent)
+                     .plugin(:rate_limiter)
+                     .with(origin: base_url)
+      end
+
+      # Get response from a path, adding the base_url,
+      # and a prefix, if set on the client.
+      #
+      # see #full_path for details
+      #
+      # @param path [String] The URL path
+      #
+      # @return [Hash] The parsed JSON response
+      def get(path, params: {})
+        get_url(full_url(path), params:)
+      end
+
+      # Get response from a URL
+      # Must pass a full URL, including scheme (http/https), host, etc.
+      #
+      # @param path [String] The full URL path
+      #
+      # @return [Hash] The parsed JSON response
+      def get_url(url, params: {})
+        uri = URI.parse(url)
+        raise ArgumentError, 'URL must be http or https' unless %w[http https].include?(uri.scheme)
+
+        response = @http.get(url, params:)
+        handle_response(response)
+      rescue ArgumentError => e
+        logger.error('Invalid URL', url:, exception: e)
+        raise Error, "Invalid URL: #{e.message}"
+      end
+
+      def market
+        @market ||= Market::Client.new(clone)
+      end
+
+      def search
+        @search ||= Search::Client.new(clone)
+      end
+
+      def events
+        @events ||= Events::Client.new(clone)
+      end
+
+      def series
+        @series ||= Series::Client.new(clone)
+      end
+
+      private
+
+      def full_url(path)
+        parts = [base_url, prefix, path].compact
+        parts.reject!(&:empty?)
+        File.join(*parts)
+      end
+
+      def handle_response(response)
+        response.raise_for_status
+        JSON.parse(response.body.to_s, symbolize_names: true)
+      rescue HTTPX::HTTPError => e
+        logger.error('API Error', e)
+        raise Error, "API Error: #{e.response.status} - #{e.response.body}"
+      end
+    end
+  end
+end

data/lib/kalshi/contract.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'reform'
+require 'reform/form/dry'
+
+module Rubyists
+  module Kalshi
+    # Base Contract class for Trailblazer/Reform forms
+    class Contract < Reform::Form
+      feature Reform::Form::Dry
+
+      # Custom class methods can be defined here
+      module ClassMethods
+        def propertize(*names)
+          # names is always an array because of the splat
+          names = names.flatten
+          const_set(:Properties, Struct.new(*custom_definitions, *names, keyword_init: true))
+          names.each { |name| property name, populator: ->(value:, **) { value || skip! } }
+        end
+      end
+
+      def self.inherited(subclass)
+        subclass.extend ClassMethods
+        super
+      end
+
+      def self.custom_definitions = instance_variable_get(:@definitions)&.keys&.map(&:to_sym) || []
+
+      def to_h
+        to_nested_hash.compact
+      end
+    end
+  end
+end

data/lib/kalshi/endpoint.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    # Base class for Kalshi API endpoints
+    class Endpoint
+      attr_reader :client
+
+      class << self
+        attr_accessor :endpoint_path
+
+        # Set the endpoint path for the resource
+        #
+        # @param path [String] API endpoint path
+        #
+        # @return [String] endpoint path
+        def kalshi_path(path)
+          self.endpoint_path = path
+        end
+      end
+
+      # Initialize the Endpoint
+      #
+      # @param client [Client] The Kalshi client
+      #
+      # @return [void]
+      def initialize(client = nil)
+        @client = client || Client.new
+      end
+    end
+  end
+end

data/lib/kalshi/events/client.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Events
+      # Events API Client
+      class Client < ApiClient
+        def list(...)
+          List.new(client).list(...)
+        end
+
+        def fetch(...)
+          List.new(client).fetch(...)
+        end
+
+        def metadata(...)
+          List.new(client).metadata(...)
+        end
+
+        def multivariate
+          Multivariate.new(client)
+        end
+
+        def candlesticks
+          Rubyists::Kalshi::Series::EventCandlesticks.new(client)
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/events/list.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Events
+      # Events API endpoint
+      class List < Kalshi::Endpoint
+        include Kalshi::Listable
+
+        kalshi_path ''
+
+        # Filter for Kalshi events list
+        class Filter < Kalshi::Contract
+          propertize(%i[limit cursor status series_ticker with_nested_markets])
+
+          validation do
+            params do
+              optional(:limit).maybe(:integer)
+              optional(:cursor).maybe(:string)
+              optional(:status).maybe(:string)
+              optional(:series_ticker).maybe(:string)
+              optional(:with_nested_markets).maybe(:bool)
+            end
+          end
+        end
+
+        def fetch(event_ticker)
+          client.get(event_ticker)
+        end
+
+        def metadata(event_ticker)
+          client.get("#{event_ticker}/metadata")
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/events/multivariate.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Events
+      # Multivariate Events API endpoint
+      class Multivariate < Kalshi::Endpoint
+        include Kalshi::Listable
+
+        kalshi_path 'multivariate'
+
+        # Filter for Kalshi multivariate events list
+        class Filter < Kalshi::Contract
+          propertize(%i[limit cursor series_ticker collection_ticker])
+
+          validation do
+            params do
+              optional(:limit).maybe(:integer)
+              optional(:cursor).maybe(:string)
+              optional(:series_ticker).maybe(:string)
+              optional(:collection_ticker).maybe(:string)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/listable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    # Mixin for listable resources
+    module Listable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Class methods for Listable
+      module ClassMethods
+        def list(...)
+          new.list(...)
+        end
+      end
+
+      # List resources
+      #
+      # @param filter [Filter|Hash] Filter options
+      #
+      # @return [Hash|Array] resource data
+      def list(filter = self.class::Filter.new(self.class::Filter::Properties.new))
+        filter = self.class::Filter.new(self.class::Filter::Properties.new(**filter)) if filter.is_a?(Hash)
+        raise ArgumentError, filter.errors.full_messages.join(', ') unless filter.validate({})
+
+        client.get(self.class.endpoint_path, params: filter.to_h)
+      end
+    end
+  end
+end

data/lib/kalshi/market/client.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Market
+      # Market API Client
+      class Client
+        attr_reader :client
+
+        def initialize(client)
+          @client = client
+        end
+
+        def series_list
+          @series_list ||= SeriesList.new(client)
+        end
+
+        def series
+          @series ||= Series.new(client)
+        end
+
+        def markets
+          @markets ||= Markets.new(client)
+        end
+
+        def orderbook
+          @orderbook ||= Orderbook.new(client)
+        end
+
+        def trades
+          @trades ||= Trades.new(client)
+        end
+
+        def candlesticks
+          @candlesticks ||= Rubyists::Kalshi::Series::MarketCandlesticks.new(client)
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/market/markets.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Market
+      # Markets API endpoint
+      class Markets < Kalshi::Endpoint
+        include Kalshi::Listable
+
+        kalshi_path 'markets'
+
+        # Filter for Kalshi markets list
+        class Filter < Kalshi::Contract
+          propertize(%i[limit cursor event_ticker series_ticker max_close_ts min_close_ts status tickers])
+
+          validation do
+            params do
+              optional(:limit).maybe(:integer)
+              optional(:cursor).maybe(:string)
+              optional(:event_ticker).maybe(:string)
+              optional(:series_ticker).maybe(:string)
+              optional(:max_close_ts).maybe(:integer)
+              optional(:min_close_ts).maybe(:integer)
+              optional(:status).maybe(:string)
+              optional(:tickers).maybe(:string)
+            end
+          end
+        end
+
+        def fetch(ticker)
+          client.get("markets/#{ticker}")
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/market/orderbook.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Market
+      # Orderbook API endpoint
+      class Orderbook < Kalshi::Endpoint
+        def fetch(ticker, depth: nil)
+          params = {}
+          params[:depth] = depth if depth
+          client.get("markets/#{ticker}/orderbook", params: params)
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/market/series.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Market
+      # Series API endpoint
+      class Series < Kalshi::Endpoint
+        def fetch(ticker)
+          client.get("series/#{ticker}")
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/market/series_list.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Market
+      # Series List API endpoint
+      class SeriesList < Kalshi::Endpoint
+        include Kalshi::Listable
+
+        kalshi_path 'series'
+
+        # Filter for Kalshi series list
+        class Filter < Kalshi::Contract
+          propertize(%i[category tags include_product_metadata isInitialized status])
+
+          validation do
+            params do
+              optional(:category).maybe(:string)
+              optional(:tags).maybe(:string)
+              optional(:include_product_metadata).maybe(:bool)
+              optional(:isInitialized).maybe(:bool)
+              optional(:status).maybe(:string)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/market/trades.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Market
+      # Trades API endpoint
+      class Trades < Kalshi::Endpoint
+        include Kalshi::Listable
+
+        kalshi_path 'markets/trades'
+
+        # Filter for Kalshi trades list
+        class Filter < Kalshi::Contract
+          propertize(%i[limit cursor ticker min_ts max_ts])
+
+          validation do
+            params do
+              optional(:limit).maybe(:integer)
+              optional(:cursor).maybe(:string)
+              optional(:ticker).maybe(:string)
+              optional(:min_ts).maybe(:integer)
+              optional(:max_ts).maybe(:integer)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/search/client.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Search
+      # Search API Client
+      class Client < ApiClient
+        def tags_by_categories
+          SeriesTags.new(client).all
+        end
+
+        def filters_by_sport
+          SportsFilters.new(client).all
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/search/series_tags.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Search
+      # Series Tags API endpoint
+      class SeriesTags < Kalshi::Endpoint
+        def all
+          client.get('tags_by_categories')
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/search/sports_filters.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Search
+      # Sports Filters API endpoint
+      class SportsFilters < Kalshi::Endpoint
+        def all
+          client.get('filters_by_sport')
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/series/client.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Series
+      # Series API Client
+      class Client < ApiClient
+        def event_candlesticks
+          EventCandlesticks.new(client)
+        end
+
+        def forecast_percentile_history
+          ForecastPercentileHistory.new(client)
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/series/event_candlesticks.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Series
+      # Event Candlesticks API endpoint
+      class EventCandlesticks < Kalshi::Endpoint
+        # Filter for Event Candlesticks
+        class EventFilter < Kalshi::Contract
+          propertize(%i[series_ticker ticker start_ts end_ts period_interval])
+
+          validation do
+            params do
+              required(:series_ticker).filled(:string)
+              required(:ticker).filled(:string)
+              required(:start_ts).filled(:integer)
+              required(:end_ts).filled(:integer)
+              required(:period_interval).filled(:integer)
+            end
+          end
+        end
+
+        def fetch(params)
+          filter = EventFilter.new(EventFilter::Properties.new(**params))
+          raise ArgumentError, filter.errors.full_messages.join(', ') unless filter.validate({})
+
+          path = "#{filter.series_ticker}/events/#{filter.ticker}/candlesticks"
+          query_params = filter.to_h.slice('start_ts', 'end_ts', 'period_interval')
+          client.get(path, params: query_params)
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/series/forecast_percentile_history.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Series
+      # Event Forecast Percentile History API endpoint
+      class ForecastPercentileHistory < Kalshi::Endpoint
+        # Filter for Event Forecast Percentile History
+        class EventFilter < Kalshi::Contract
+          propertize(%i[series_ticker ticker percentiles start_ts end_ts period_interval])
+
+          validation do
+            params do
+              required(:series_ticker).filled(:string)
+              required(:ticker).filled(:string)
+              required(:percentiles).filled(:array)
+              required(:start_ts).filled(:integer)
+              required(:end_ts).filled(:integer)
+              required(:period_interval).filled(:integer)
+            end
+          end
+        end
+
+        def fetch(params)
+          filter = EventFilter.new(EventFilter::Properties.new(**params))
+          raise ArgumentError, filter.errors.full_messages.join(', ') unless filter.validate({})
+
+          path = "#{filter.series_ticker}/events/#{filter.ticker}/forecast_percentile_history"
+          query_params = filter.to_h.slice('start_ts', 'end_ts', 'period_interval')
+          query_params[:percentiles] = filter.percentiles.join(',')
+          client.get(path, params: query_params)
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/series/market_candlesticks.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Kalshi
+    module Series
+      # Candlesticks API endpoint
+      class MarketCandlesticks < Kalshi::Endpoint
+        def fetch(series_ticker:, ticker:, start_ts:, end_ts:, period_interval:)
+          path = "series/#{series_ticker}/markets/#{ticker}/candlesticks"
+          params = { start_ts:, end_ts:, period_interval: }
+          client.get(path, params:)
+        end
+
+        def batch(tickers:, series_ticker:, start_ts:, end_ts:, period_interval:)
+          path = 'markets/candlesticks'
+          params = {
+            market_tickers: tickers.is_a?(Array) ? tickers.join(',') : tickers,
+            series_ticker:,
+            start_ts:,
+            end_ts:,
+            period_interval:
+          }
+          client.get(path, params:)
+        end
+      end
+    end
+  end
+end

data/lib/kalshi/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Rubyists
+  # Kalshi module version
+  module Kalshi
+    # x-release-please-start-version
+    VERSION = '0.1.0'
+    # x-release-please-end
+  end
+end