rito 0.1.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b88f9486b198ec08703fb9124aaea6d20d8c7313488d61d06541d289b7caf8b
-  data.tar.gz: a5acab9fe9d2cd25ca2e1a64e674d3ffc61e7ce3ae46896e4947a8dc93c267a3
+  metadata.gz: 9088da4cb186a04b00b160ac7ee8ddaf8c26bb7f48e10f4db80c20bb5d2dff7b
+  data.tar.gz: 7323a3cf554a3f60c8f85ee05635e74101cd767d3befe47ca5e467f6bfc61cc3
 SHA512:
-  metadata.gz: 381057a97d7fd77f04f13cfcaa8e394d472dd1dbe4bafb7aef1ad8c696a681587c4ced5db2e93a1d1d120ca76ca7e603d7be701954e91b650f04a7d83d7d28c9
-  data.tar.gz: 783a2bdf9c817180d9caa160ec9429af4cf34a3df15b69382c5c653dc49cb5a1c909b87ef58277233c8990cfdfc588259892f8b776bc24ea11e22e64fe0ff55c
+  metadata.gz: 8fa6f315096ecbf7cdb8ac2dc72b31e39c37bcaffa4f2d1a81e4b62f44737fc5611a89d253191d19835b4048c57feb608fd91ea1cdf61d02b84e3fe81e3f6998
+  data.tar.gz: 40775c60207a3e639c5590680285ad4ccd6271c257588c6d29bee31c998baa19efd45468bab04063e0eee52c94426aaf127c77a407f5f9159583d8b249f40fe4

data/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 0.3.0 (2026-09-05)
+
+Aligned the endpoint surface with the current Riot API reference
+(cross-checked against riotapi-schema). **Breaking:** phantom endpoints
+Riot has removed were dropped, and outdated paths were corrected.
+
+- **Removed (no longer in the API docs)**: summoner-v4 `by_name` /
+  `by_account_id` / `by_summoner_id`; TFT summoner `by_account_id` /
+  `by_summoner_id`; spectator-v5 and spectator-tft-v5 `featured_games`;
+  league-v4 `league(leagueId)` and `entries_by_summoner_id`; TFT league
+  `entries_by_summoner_id`; clash `players_by_summoner_id`; LoR
+  `decks.deck(deck_id)`; tournament-stub `update_code`.
+- **Renamed/fixed paths**: spectator active games (`by-summoner-id` →
+  `by-summoner/{puuid}`, TFT: `by-puuid/{puuid}`), TFT league routing is
+  platform (`na1`), not regional; tournament-v5/stub code paths
+  (`codes/by-code/{code}` → `codes/{code}`); challenges leaderboard param
+  `top`/`page` → `limit`.
+- **Added**: `lol-rso-match-v1` (`client.rso_matches` — RSO bearer token;
+  `ids`, `by_id`, `timeline_by_id`), `val-console-ranked-v1`
+  (`client.val.console_ranked` with required `platform_type:`),
+  match-v5 `replays`, tournament-v5 `games_by_code`, clash
+  `tournament(tournamentId)`, league-v4 `entries_by_puuid`, TFT league
+  `entries_by_puuid` / `entries(tier, division)`, challenges
+  `challenge_config` / `challenge_percentiles`, summoner-v4 `me` (RSO),
+  LoR `decks.create_deck` (POST).
+- **Queues reference**: `Rito::Queues` — frozen snapshot of the League
+  client's game select data (408 queue ids) with name, description,
+  category (`:pvp` / `:bots` / `:custom`), mode, limited-time and bot
+  flags; `MatchInfo#queue` resolves a match's `queueId`.
+- **Routing**: VALORANT platform `na1` → `na`; VALORANT platforms accept
+  `esports` (content/match only) and console accepts `br`/`latam`
+  (console match); dropped dead `ph2`/`th2`; added `pbe1` (challenges,
+  status) and `esports`/`esportseu` regionals (tft-match-v1).
+
+## 0.2.0 (2026-09-05)
+
+- **Riot Sign On (RSO)**: new `Rito::RSO` module implementing the OAuth2
+  authorization code flow against `auth.riotgames.com`:
+  `authorization_url` (with generated CSRF state), `exchange_code`,
+  `refresh`, `userinfo`, and `verify_id_token` (RS256 signature +
+  iss/aud/exp validation via `/jwks.json`, with key-rotation-aware
+  refetch). Token requests support `client_secret` basic, a static
+  `client_assertion` (the RSO "100 year token"), or minted private-key
+  JWT client assertions from an RSA `private_key`. Zero new runtime
+  dependencies (stdlib `openssl`).
+
 ## 0.1.3 (2026-09-05)
 
 - CI: publish via `rubygems/release-gem` so releases carry a Sigstore

data/README.md

@@ -44,6 +44,103 @@ Rito.rate_limiter   # rate limit strategy (default: AdaptiveLimiter)
 client = Rito::Client.new(api_key: "RGAPI-...", region: :kr)
 ```
 
+## Queues
+
+`Rito::Queues` is a frozen, built-in reference for League queue ids as
+they appear in match data (match-v5 `queueId`, the `queue` filter on
+match lists). Snapshot of the League client's game select data (408 ids).
+
+```ruby
+Rito::Queues.find(420).name        # => "Ranked Solo/Duo"
+Rito::Queues[450].mode             # => :aram
+Rito::Queues.find(2450).limited_time # => true (rotating game mode)
+Rito::Queues.select { |q| q.category == :bots }.map(&:name).first(3)
+
+match = client.matches.by_id("NA1_123")
+match.info.queue.name              # => "Ranked Flex" (convenience on MatchInfo)
+```
+
+Each queue is a frozen `Data` object: `id`, `name`, `short_name`,
+`description`, `detailed_description`, `category` (`:pvp`, `:bots`,
+`:custom`), `mode` (`:summoners_rift`, `:aram`, `:tft`, `:jade`,
+`:other`), `limited_time`, `bot_honoring_allowed`. The module includes
+`Enumerable`. Unknown ids return `nil` (Riot adds queues without notice).
+
+## Riot Sign On (RSO)
+
+`Rito::RSO` implements the OAuth2 authorization code flow against
+`https://auth.riotgames.com`. Register a client with Riot first; the
+redirect URI must be on its allowlist.
+
+```ruby
+rso = Rito::RSO::Client.new(
+  client_id: ENV.fetch("RIOT_RSO_CLIENT_ID"),
+  client_secret: ENV.fetch("RIOT_RSO_CLIENT_SECRET"), # or client_assertion: / private_key:
+  redirect_uri: "https://app.example.com/oauth2-callback"
+)
+
+# 1. Send the player to Riot; persist request.state to compare on callback
+login = rso.authorization_url(login_hint: "na1|daguava")
+login.url     # => "https://auth.riotgames.com/authorize?..."
+login.state
+
+# 2. Exchange the ?code= query param from the callback for tokens
+tokens = rso.exchange_code(params[:code])
+tokens.access_token   # Bearer token for RSO resources (encrypted, opaque)
+tokens.id_token       # signed JWT identity token
+tokens.refresh_token  # signed JWT, self-contained
+tokens.expires_in     # 600
+
+# 3. Identify the player
+me = rso.userinfo(tokens.access_token)
+me.sub    # player sub claim
+me.cpid   # "NA1" when the cpid scope was requested
+
+# 4. Rotate when the access token expires
+tokens = rso.refresh(tokens.refresh_token)
+```
+
+Newer RSO clients authenticate with private-key JWT instead of a secret
+(the gem mints a fresh signed assertion per token request):
+
+```ruby
+rso = Rito::RSO::Client.new(
+  client_id: ENV.fetch("RIOT_RSO_CLIENT_ID"),
+  private_key: OpenSSL::PKey::RSA.new(ENV.fetch("RIOT_RSO_PRIVATE_KEY")),
+  redirect_uri: "https://app.example.com/oauth2-callback"
+)
+```
+
+or pass the pre-signed client assertion (the "100 year token") via
+`client_assertion:` and treat it like a password.
+
+### Verifying the ID token
+
+```ruby
+claims = rso.verify_id_token(tokens.id_token)
+claims["sub"] # => signature (RS256 via /jwks.json) + iss/aud/exp validated
+```
+
+`verify_id_token` caches the JWKS document and refetches it once when a
+`kid` is unknown (Riot rotates keypairs without disabling old ones).
+Any failure raises `Rito::RSO::InvalidToken`. Token and userinfo failures
+raise `Rito::RSO::OAuthError` with `.error_code` / `.error_description`.
+
+### RSO configuration
+
+```ruby
+Rito::RSO.client_id        # default: ENV["RIOT_RSO_CLIENT_ID"]
+Rito::RSO.client_secret    # default: ENV["RIOT_RSO_CLIENT_SECRET"]
+Rito::RSO.client_assertion # default: ENV["RIOT_RSO_CLIENT_ASSERTION"]
+Rito::RSO.private_key
+Rito::RSO.redirect_uri     # default: ENV["RIOT_RSO_REDIRECT_URI"]
+Rito::RSO.scope            # default: "openid" (add cpid / offline_access)
+```
+
+Per-instance kwargs override the module config. Token requests are never
+retried (authorization codes and refresh tokens are one-time), so handle
+failures explicitly.
+
 ## Routing values
 
 Endpoints declare whether they are platform-routed (`na1`, `kr`, ...) or
@@ -124,9 +221,10 @@ entry.raw       # => full payload hash
 
 | Accessor | API |
 | --- | --- |
-| `client.account` | account-v1 |
-| `client.summoner` | summoner-v4 |
-| `client.matches` | match-v5 (matches, matchlist, timeline) |
+| `client.account` | account-v1 (accounts, active shards, region, `me` for RSO) |
+| `client.summoner` | summoner-v4 (`by_puuid`, `me` for RSO) |
+| `client.matches` | match-v5 (matches, matchlist, timeline, replays) |
+| `client.rso_matches` | lol-rso-match-v1 (RSO bearer token; player resolved from the token) |
 | `client.champion_masteries` | champion-mastery-v4 |
 | `client.champions` | champion-v3 (rotations) |
 | `client.leagues` / `client.league_exp` | league-v4 / league-exp-v4 |
@@ -136,12 +234,16 @@ entry.raw       # => full payload hash
 | `client.challenges` | lol-challenges-v1 |
 | `client.tournaments` / `client.tournament_stub` | tournament-v5 / stub-v5 |
 | `client.tft.summoner` / `.leagues` / `.matches` / `.status` / `.spectator` | tft-summoner-v1, tft-league-v1, tft-match-v1, tft-status-v1, spectator-tft-v5 |
-| `client.val.content` / `.matches` / `.console_matches` / `.ranked` / `.status` | val-content-v1, val-match-v1, val-console-match-v1, val-ranked-v1, val-status-v1 |
+| `client.val.content` / `.matches` / `.console_matches` / `.ranked` / `.console_ranked` / `.status` | val-content-v1, val-match-v1, val-console-match-v1, val-ranked-v1, val-console-ranked-v1, val-status-v1 |
 | `client.lor.matches` / `.ranked` / `.status` / `.decks` / `.inventory` | lor-match-v1, lor-ranked-v1, lor-status-v1, lor-deck-v1 / lor-inventory-v1 (RSO) |
 | `client.riftbound` | riftbound-content-v1 |
 
-Note: VALORANT uses its own platform routing values (`na1, eu, ap, kr, latam, br`;
-console: `na, eu, ap`) — the client validates against the right set per product.
+Note: VALORANT uses its own platform routing values (`na, eu, ap, kr,
+latam, br`; console: `na, eu, ap, br, latam`) — the client validates
+against the right set per product. `esports` is a valid platform for
+VALORANT content/match and a valid regional for tft-match-v1 (with
+`esportseu`). The tournament endpoints only exist on the `americas`
+platform — pass `region: :na1` or `:americas`.
 
 ## Testing your own app
 

data/lib/rito/client.rb

@@ -32,6 +32,10 @@ module Rito
       Endpoints::Lol::MatchV5.new(self)
     end
 
+    def rso_matches
+      Endpoints::Lol::RsoMatchV1.new(self)
+    end
+
     def champion_masteries
       Endpoints::Lol::ChampionMasteryV4.new(self)
     end

data/lib/rito/endpoints/lol/challenges_v1.rb

@@ -10,14 +10,21 @@ module Rito
           get('/lol/challenges/v1/challenges/config', region)
         end
 
+        def challenge_config(challenge_id, region: nil)
+          get("/lol/challenges/v1/challenges/#{escape(challenge_id)}/config", region)
+        end
+
         def percentiles(region: nil)
           get('/lol/challenges/v1/challenges/percentiles', region)
         end
 
-        def leaderboard(challenge_id, level, top: nil, page: nil, region: nil)
+        def challenge_percentiles(challenge_id, region: nil)
+          get("/lol/challenges/v1/challenges/#{escape(challenge_id)}/percentiles", region)
+        end
+
+        def leaderboard(challenge_id, level, limit: nil, region: nil)
           params = {}
-          params['top'] = top if top
-          params['page'] = page if page
+          params['limit'] = limit if limit
           get("/lol/challenges/v1/challenges/#{escape(challenge_id)}/leaderboards/by-level/#{escape(level)}", region,
               params: params)
         end

data/lib/rito/endpoints/lol/clash_v1.rb

@@ -6,8 +6,8 @@ module Rito
       class ClashV1 < Base
         ROUTING = :platform
 
-        def players_by_summoner_id(summoner_id, region: nil)
-          get("/lol/clash/v1/players/by-summoner/#{escape(summoner_id)}", region)
+        def players_by_puuid(puuid, region: nil)
+          get("/lol/clash/v1/players/by-puuid/#{escape(puuid)}", region)
         end
 
         def team(team_id, region: nil)
@@ -18,6 +18,10 @@ module Rito
           get('/lol/clash/v1/tournaments', region)
         end
 
+        def tournament(tournament_id, region: nil)
+          get("/lol/clash/v1/tournaments/#{escape(tournament_id)}", region)
+        end
+
         def tournament_by_team(team_id, region: nil)
           get("/lol/clash/v1/tournaments/by-team/#{escape(team_id)}", region)
         end

data/lib/rito/endpoints/lol/league_v4.rb

@@ -24,8 +24,8 @@ module Rito
           )
         end
 
-        def entries_by_summoner_id(summoner_id, region: nil)
-          get("/lol/league/v4/entries/by-summoner/#{escape(summoner_id)}", region)
+        def entries_by_puuid(puuid, region: nil)
+          get("/lol/league/v4/entries/by-puuid/#{escape(puuid)}", region)
             .map { |hash| Models::LeagueEntry.from_api(hash) }
         end
 
@@ -35,12 +35,6 @@ module Rito
           get("/lol/league/v4/entries/#{escape(tier)}/#{escape(division)}", region, params: params)
             .map { |hash| Models::LeagueEntry.from_api(hash) }
         end
-
-        def league(league_id, region: nil)
-          Models::LeagueList.from_api(
-            get("/lol/league/v4/leagues/#{escape(league_id)}", region)
-          )
-        end
       end
 
       class LeagueExpV4 < Base

data/lib/rito/endpoints/lol/match_v5.rb

@@ -28,6 +28,12 @@ module Rito
         def timeline_by_id(match_id, region: nil)
           get("/lol/match/v5/matches/#{escape(match_id)}/timeline", region)
         end
+
+        def replays(puuid, region: nil)
+          Models::Replay.from_api(
+            get("/lol/match/v5/matches/by-puuid/#{escape(puuid)}/replays", region)
+          )
+        end
       end
     end
   end

data/lib/rito/endpoints/lol/rso_match_v1.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rito
+  module Endpoints
+    module Lol
+      # Requires the client to be configured with a bearer_token (RSO) instead
+      # of an API key. The player is identified by the token itself; payload
+      # shapes are the same as match-v5.
+      class RsoMatchV1 < Base
+        ROUTING = :regional
+
+        def ids(region: nil, start: nil, count: nil, queue: nil,
+                type: nil, start_time: nil, end_time: nil)
+          params = {}
+          params['start'] = start if start
+          params['count'] = count if count
+          params['queue'] = queue if queue
+          params['type'] = type if type
+          params['startTime'] = start_time if start_time
+          params['endTime'] = end_time if end_time
+
+          get('/lol/rso-match/v1/matches/ids', region, params: params)
+        end
+
+        def by_id(match_id, region: nil)
+          Models::Match.from_api(
+            get("/lol/rso-match/v1/matches/#{escape(match_id)}", region)
+          )
+        end
+
+        def timeline_by_id(match_id, region: nil)
+          get("/lol/rso-match/v1/matches/#{escape(match_id)}/timeline", region)
+        end
+      end
+    end
+  end
+end

data/lib/rito/endpoints/lol/spectator_v5.rb

@@ -7,15 +7,11 @@ module Rito
         ROUTING = :platform
 
         # Returns nil when the summoner is not in an active game (HTTP 404).
-        def active_game(summoner_id, region: nil)
-          get("/lol/spectator/v5/active-games/by-summoner-id/#{escape(summoner_id)}", region)
+        def active_game(puuid, region: nil)
+          get("/lol/spectator/v5/active-games/by-summoner/#{escape(puuid)}", region)
         rescue NotFound
           nil
         end
-
-        def featured_games(region: nil)
-          get('/lol/spectator/v5/featured-games', region)
-        end
       end
     end
   end

data/lib/rito/endpoints/lol/summoner_v4.rb

@@ -12,22 +12,9 @@ module Rito
           )
         end
 
-        def by_name(name, region: nil)
-          Models::Summoner.from_api(
-            get("/lol/summoner/v4/summoners/by-name/#{escape(name)}", region)
-          )
-        end
-
-        def by_account_id(account_id, region: nil)
-          Models::Summoner.from_api(
-            get("/lol/summoner/v4/summoners/by-account/#{escape(account_id)}", region)
-          )
-        end
-
-        def by_summoner_id(summoner_id, region: nil)
-          Models::Summoner.from_api(
-            get("/lol/summoner/v4/summoners/#{escape(summoner_id)}", region)
-          )
+        # Requires the client to be configured with a bearer_token (RSO).
+        def me(region: nil)
+          Models::Summoner.from_api(get('/lol/summoner/v4/summoners/me', region))
         end
       end
     end

data/lib/rito/endpoints/lol/tournament_v5.rb

@@ -8,7 +8,7 @@ module Rito
         PREFIX = '/lol/tournament/v5'
 
         def code(tournament_code, region: nil)
-          get("#{PREFIX}/codes/by-code/#{escape(tournament_code)}", region)
+          get("#{PREFIX}/codes/#{escape(tournament_code)}", region)
         end
 
         def create_codes(tournament_id:, count: nil, body: {}, region: nil)
@@ -18,7 +18,11 @@ module Rito
         end
 
         def update_code(tournament_code, body: {}, region: nil)
-          put("#{PREFIX}/codes/by-code/#{escape(tournament_code)}", region, body: body)
+          put("#{PREFIX}/codes/#{escape(tournament_code)}", region, body: body)
+        end
+
+        def games_by_code(tournament_code, region: nil)
+          get("#{PREFIX}/games/by-code/#{escape(tournament_code)}", region)
         end
 
         def lobby_events(tournament_code, region: nil)
@@ -39,7 +43,7 @@ module Rito
         PREFIX = '/lol/tournament-stub/v5'
 
         def code(tournament_code, region: nil)
-          get("#{PREFIX}/codes/by-code/#{escape(tournament_code)}", region)
+          get("#{PREFIX}/codes/#{escape(tournament_code)}", region)
         end
 
         def create_codes(tournament_id:, count: nil, body: {}, region: nil)
@@ -48,10 +52,6 @@ module Rito
           post("#{PREFIX}/codes", region, params: params, body: body)
         end
 
-        def update_code(tournament_code, body: {}, region: nil)
-          put("#{PREFIX}/codes/by-code/#{escape(tournament_code)}", region, body: body)
-        end
-
         def lobby_events(tournament_code, region: nil)
           get("#{PREFIX}/lobby-events/by-code/#{escape(tournament_code)}", region)
         end

data/lib/rito/endpoints/lor.rb

@@ -39,8 +39,9 @@ module Rito
           get('/lor/deck/v1/decks/me', region)
         end
 
-        def deck(deck_id, region: nil)
-          get("/lor/deck/v1/decks/me/#{escape(deck_id)}", region)
+        # Requires the client to be configured with a bearer_token (RSO).
+        def create_deck(body:, region: nil)
+          post('/lor/deck/v1/decks/me', region, body: body)
         end
       end
 

data/lib/rito/endpoints/tft.rb

@@ -11,14 +11,6 @@ module Rito
           Models::Summoner.from_api(get("#{PREFIX}/by-puuid/#{escape(puuid)}", region))
         end
 
-        def by_account_id(account_id, region: nil)
-          Models::Summoner.from_api(get("#{PREFIX}/by-account/#{escape(account_id)}", region))
-        end
-
-        def by_summoner_id(summoner_id, region: nil)
-          Models::Summoner.from_api(get("#{PREFIX}/#{escape(summoner_id)}", region))
-        end
-
         # Requires the client to be configured with a bearer_token (RSO).
         def me(region: nil)
           Models::Summoner.from_api(get("#{PREFIX}/me", region))
@@ -26,14 +18,17 @@ module Rito
       end
 
       class LeagueV1 < Base
-        ROUTING = :regional
+        ROUTING = :platform
+
+        def entries_by_puuid(puuid, region: nil)
+          get("/tft/league/v1/by-puuid/#{escape(puuid)}", region)
+        end
 
-        def entries_by_summoner_id(summoner_id, queue: nil, tier: nil, division: nil, region: nil)
+        def entries(tier, division, queue: nil, page: nil, region: nil)
           params = {}
           params['queue'] = queue if queue
-          params['tier'] = tier if tier
-          params['division'] = division if division
-          get("/tft/league/v1/entries/by-summoner/#{escape(summoner_id)}", region, params: params)
+          params['page'] = page if page
+          get("/tft/league/v1/entries/#{escape(tier)}/#{escape(division)}", region, params: params)
         end
 
         def challenger(region: nil)
@@ -80,15 +75,11 @@ module Rito
         ROUTING = :platform
 
         # Returns nil when the summoner is not in an active game (HTTP 404).
-        def active_game(summoner_id, region: nil)
-          get("/tft/spectator/v5/active-games/by-summoner-id/#{escape(summoner_id)}", region)
+        def active_game(puuid, region: nil)
+          get("/lol/spectator/tft/v5/active-games/by-puuid/#{escape(puuid)}", region)
         rescue NotFound
           nil
         end
-
-        def featured_games(region: nil)
-          get('/tft/spectator/v5/featured-games', region)
-        end
       end
     end
   end

data/lib/rito/endpoints/valorant.rb

@@ -52,6 +52,17 @@ module Rito
         end
       end
 
+      class ConsoleRankedV1 < Base
+        ROUTING = :valorant_console_platform
+
+        def leaderboard(act_id, platform_type:, size: nil, start_index: nil, region: nil)
+          params = { 'platformType' => platform_type }
+          params['size'] = size if size
+          params['startIndex'] = start_index if start_index
+          get("/val/console/ranked/v1/leaderboards/by-act/#{escape(act_id)}", region, params: params)
+        end
+      end
+
       class StatusV1 < Base
         ROUTING = :valorant_platform
 
@@ -80,6 +91,10 @@ module Rito
         Endpoints::Valorant::ConsoleMatchV1.new(@client)
       end
 
+      def console_ranked
+        Endpoints::Valorant::ConsoleRankedV1.new(@client)
+      end
+
       def ranked
         Endpoints::Valorant::RankedV1.new(@client)
       end

data/lib/rito/models/match.rb

@@ -31,6 +31,10 @@ module Rito
     MatchInfo = Data.define(:game_creation, :game_duration, :game_end_timestamp,
                             :game_id, :game_mode, :game_start_timestamp, :game_type,
                             :game_version, :map_id, :participants, :queue_id, :raw) do
+      def queue
+        Rito::Queues.find(queue_id)
+      end
+
       def self.from_api(hash)
         return nil if hash.nil?
 
@@ -67,5 +71,15 @@ module Rito
         )
       end
     end
+
+    Replay = Data.define(:total, :match_file_urls, :raw) do
+      def self.from_api(hash)
+        new(
+          total: hash['total'],
+          match_file_urls: hash['matchFileURLs'],
+          raw: hash.freeze
+        )
+      end
+    end
   end
 end