sorare-rewards 0.1.0.beta11 → 1.0.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77c0cb011e78b240a5708daaef48b59be3bd6919c44fc0a84515314c77e2ee10
-  data.tar.gz: d248dd322adda855d1668f9b6cc3424d98c0c0a33dc95f5d7caf2b9b457b3fd7
+  metadata.gz: 8b703ed076cf77397da8c97fcae63c48379b11fda722bcb047c9e9a7e2f47fb9
+  data.tar.gz: 6a428a838d574916a4a5ad3dedbc79046845a4f9b6009b28fde70adbc1ac673d
 SHA512:
-  metadata.gz: 921aa2e26ae7271027c6c91887e6a8a4bf975f4084bfce759871ca1a25192e8420c8aa25a5a9ed1e3854d4ec99d756fd267f7b66ee8c3bf5f36c0f7c3f33f49e
-  data.tar.gz: fc32cd8862c4de110f9a6d2f101755230a5aaa9c1b0c89bfbbba48b4d8ce5b9ab1d0a09afb2772d3db9f026d1879bee37c6c5ddd11faebb47e4385242a9baf97
+  metadata.gz: cea7dd5e7e61647fa6a30718917059a1dd25f34d864c6214f44959d4a546665db3b0125a00742da5216d1ed56284d28f4f5403cca77fb1c714089759aaf371de
+  data.tar.gz: dd66f18067ae9b07202ac98d0e89b2a80cc52042726ab40eb6da73fa947905aca45343b319815ed8917031ba53dd993ca90b6ec2a484f9e05dea75449e9954e4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorare-rewards (0.1.0.beta11)
+    sorare-rewards (1.0.0.beta4)
       activesupport (~> 6.1)
       interactor (~> 3.0)
       json (~> 2)

data/lib/sorare/rewards/configuration.rb

@@ -6,19 +6,21 @@ module Sorare
   module Rewards
     # Configuration stores the runtime configuration
     class Configuration
-      attr_accessor :tiers, :gateway, :transform_tier, :transform_division, :allocation_configuration
+      attr_accessor :tiers, :gateway, :transform_tier, :transform_division,
+                    :allocation_configuration, :prize_pool_configuration
 
       def initialize
         @tiers = 4
         @gateway = 'https://gateway.pinata.cloud/ipfs/'
         @transform_tier = ->(tier) { "tier_#{tier}" }
         @transform_division = ->(division) { "D#{division}" }
-        @allocation_configuration = load_configuration
+        @allocation_configuration = load_yaml_configuration_file('allocation_configuration.yml')['leagues']
+        @prize_pool_configuration = load_yaml_configuration_file('prize_pool_configuration.yml')['rates']
       end
 
-      def load_configuration
-        YAML.safe_load(File.read("#{File.dirname(__FILE__)}/allocation_configuration.yml"), [], [], true)
-            .with_indifferent_access['leagues']
+      def load_yaml_configuration_file(filename)
+        YAML.safe_load(File.read("#{File.dirname(__FILE__)}/#{filename}"), [], [], true)
+            .with_indifferent_access
       end
     end
   end

data/lib/sorare/rewards/game_week.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+
+module Sorare
+  module Rewards
+    # GameWeek stores the reward data of a game week
+    class GameWeek
+      attr_reader :data, :config, :salt
+
+      def initialize(data: nil, hash: nil, salt: nil)
+        uri = URI("#{Sorare::Rewards.configuration.gateway}#{hash}")
+        @data = data || JSON.parse(::Net::HTTP.get(uri))
+        @config = GameWeekConfig.new(@data['config'])
+        @salt = salt
+      end
+
+      %w[public_seed version supply playing_players leagues].each do |key|
+        define_method(key) do
+          data[key]
+        end
+      end
+
+      def supply_for(league, rarity: nil, player: nil)
+        return (supply.dig(league, rarity, player) || 0) if rarity && player
+        return (supply.dig(league, rarity) || {}) if rarity
+
+        supply[league] || {}
+      end
+
+      def each_league
+        (leagues || {}).each_key do |league_name|
+          return to_enum(:each_league) unless block_given?
+
+          yield(league(league_name))
+        end
+      end
+
+      def rewards
+        raise 'Salt required' unless salt
+
+        @rewards ||= Sorare::Rewards::Build.call!(game_week: self, salt: salt)
+      end
+
+      def card_rewards
+        @card_rewards ||= Sorare::Rewards::Pick.call!(rewards.to_h)
+      end
+
+      def league(name)
+        raise 'Unknown league' unless (leagues || {})[name]
+
+        League.new(
+          game_week: self, name: name, config: leagues[name], supply: supply[leagues.dig(name, 'pool_supply')]
+        )
+      end
+
+      def player(slug)
+        Player.new(slug, self)
+      end
+    end
+  end
+end

data/lib/sorare/rewards/game_week_allocations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sorare
+  module Rewards
+    # GameWeekAllocations stores the expected allocations for a game week
+    class GameWeekAllocations
+      attr_reader :allocations
+
+      def initialize(allocations)
+        @allocations = allocations
+      end
+
+      def each_league_allocations
+        allocations.each_key do |league_name|
+          return to_enum(:each_league_allocations) unless block_given?
+
+          yield(league_name, allocations[league_name])
+        end
+      end
+
+      def each_league_rarity_allocations
+        each_league_allocations do |league_name, league_allocations|
+          league_allocations.each_key do |rarity|
+            return to_enum(:each_league_rarity_allocations) unless block_given?
+
+            yield(league_name, rarity, league_allocations[rarity])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/game_week_config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Sorare
+  module Rewards
+    # GameWeekConfig stores the config used to reward a game week
+    class GameWeekConfig
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      %w[cooldown limits prize_pool_currency].each do |key|
+        define_method(key) do
+          config[key]
+        end
+      end
+
+      def over_limit?(rarity, rewarded)
+        limits[rarity] <= rewarded
+      end
+
+      def distribution_limit(rarity)
+        limits[rarity]
+      end
+
+      def cooldown_limit(rarity)
+        cooldown.dig(rarity, 'quantity')
+      end
+
+      def cooldown_since(rarity)
+        cooldown.dig(rarity, 'since')
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'interactor'
+
+module Sorare
+  module Rewards
+    # Interactor extends Interactor to improve on it
+    module Interactor
+      extend ActiveSupport::Concern
+
+      included do
+        include ::Interactor
+
+        # make sure we fail the current context when a call! to another interactor fails
+        around do |interactor|
+          interactor.call
+        rescue ::Interactor::Failure => e
+          context.fail!(error: e.context.error)
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/allocations/compute_for_game_week.rb

@@ -2,7 +2,6 @@
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/enumerable'
-require 'interactor'
 
 module Sorare
   module Rewards

data/lib/sorare/rewards/interactors/allocations/compute_for_league.rb

@@ -2,7 +2,6 @@
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/enumerable'
-require 'interactor'
 
 module Sorare
   module Rewards

data/lib/sorare/rewards/interactors/allocations/compute_for_quality.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards

data/lib/sorare/rewards/interactors/allocations/compute_for_rarity.rb

@@ -2,7 +2,6 @@
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/enumerable'
-require 'interactor'
 
 module Sorare
   module Rewards

data/lib/sorare/rewards/interactors/build.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards
@@ -11,22 +8,27 @@ module Sorare
     class Build
       include Interactor
 
-      delegate :data, :salt, to: :context
+      delegate :game_week, :salt, to: :context
 
       def call
-        context.game_week_supply = game_week_supply
-        context.allocations = allocate!
+        context.card_allocations = allocate!
+        context.prize_pools = prize_pools!
+        context.prize_pool_currency = game_week.config.prize_pool_currency
+      end
+
+      def game_week_supply
+        @game_week_supply ||= Supply::ComputeForGameWeek.call!(game_week: game_week, salt: salt)
+                                                        .game_week_supply
       end
 
       def allocate!
         Allocations::ComputeForGameWeek.call!(
-          **data.to_h, supply: game_week_supply, salt: salt
+          game_week: game_week, supply: game_week_supply, salt: salt
         ).game_week_allocations
       end
 
-      def game_week_supply
-        @game_week_supply ||= Supply::ComputeForGameWeek.call!(**data.to_h, salt: salt)
-                                                        .game_week_supply
+      def prize_pools!
+        PrizePools::ComputeForGameWeek.call!(game_week: game_week, salt: salt).prize_pools
       end
     end
   end

data/lib/sorare/rewards/interactors/cards/pick_for_division.rb

@@ -2,23 +2,16 @@
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/enumerable'
-require 'interactor'
 require 'yaml'
 
 module Sorare
   module Rewards
     module Cards
       # PickForDivision picks the rewards for a given division
-      # Receive a list of eligible qualified cards
+      # Receive a list of pickers for each tiers and quality
       #   {
-      #     'rare' => {
-      #       0 => ['kylian-mbappe-lottin', 'kylian-mbappe-lottin', 'keylor-navas', ...]
-      #     }
-      #   }
-      # A game week league supply
-      #   {
-      #     'rare' => { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...},
-      #     'super_rare' => { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...}
+      #     'rare' => { 'tier_0' => Picker, 'tier_1' => Picker },
+      #     'super_rare' => { 'tier_0' => Picker, 'tier_1' => Picker }
       #   }
       # And a reward allocations
       #   {
@@ -29,12 +22,15 @@ module Sorare
       class PickForDivision
         include Interactor
 
-        delegate :allocations, :cards, :qualified_players, :supply, to: :context
+        delegate :league, :allocations, :pickers, :qualified_players, to: :context
 
         def call
           context.division_picks = allocations.keys.index_with do |rarity|
             PickForDivisionAndRarity.call!(
-              **context.to_h, cards: cards[rarity], allocations: allocations[rarity], supply: supply[rarity]
+              **context.to_h,
+              rarity: rarity,
+              pickers: pickers[rarity],
+              allocations: allocations[rarity]
             ).rarity_picks
           end
         end

data/lib/sorare/rewards/interactors/cards/pick_for_division_and_rarity.rb

@@ -2,24 +2,22 @@
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/enumerable'
-require 'interactor'
 
 module Sorare
   module Rewards
     module Cards
       # PickForDivisionAndRarity picks the rewards for a given division and rarity
-      # Receive a randomizer, a list of eligible qualified cards of the corresponding rarity
+      # Receive a list of pickers for each tiers
       #   {
-      #     'tier_0' => ['kylian-mbappe-lottin', 'kylian-mbappe-lottin', 'keylor-navas', ...]
+      #     'tier_0' => Picker, 'tier_1' => Picker
       #   }
-      # A game week league rarity supply
-      #   { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...}
+      # A game week data
       # And a reward allocations
       #   { 'tier_0' => 1, 'tier_1' => 2 }
       class PickForDivisionAndRarity
         include Interactor
 
-        delegate :allocations, :cards, to: :context
+        delegate :league, :rarity, :allocations, :pickers, to: :context
 
         def call
           context.rarity_picks = supply!
@@ -27,8 +25,10 @@ module Sorare
 
         def supply!
           allocations.keys.index_with do |tier|
+            next [] if pickers&.dig(tier).nil?
+
             PickForDivisionRarityAndQuality.call!(**context.to_h, allocations: allocations[tier],
-                                                                  cards: cards[tier]).picks
+                                                                  picker: pickers[tier]).picks
           end
         end
       end

data/lib/sorare/rewards/interactors/cards/pick_for_division_rarity_and_quality.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards
     module Cards
       # PickForDivisionRarityAndQuality picks the rewards for a given division, rarity, and quality
-      # Receive a list of eligible qualified cards
-      #   ['kylian-mbappe-lottin', 'kylian-mbappe-lottin', 'keylor-navas', ...]
-      # A game week league rarity supply
-      #   { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...}
+      # Receive a picker
+      # A game week data
       # And a reward allocations
       #   15
       class PickForDivisionRarityAndQuality
@@ -18,7 +15,8 @@ module Sorare
 
         MISSING_CARDS = 'There are not enough cards to fulfill the requirements'
 
-        delegate :cards, :allocations, :supply, :force, :picks, :randomizer, to: :context
+        delegate :picker, :allocations, :league, :rarity, :force, :picks, to: :context
+        delegate :game_week, to: :league
 
         def call
           context.picks = []
@@ -29,13 +27,20 @@ module Sorare
         end
 
         def pick!
-          while picks.length != allocations && cards.length.positive?
-            picks.push(cards.delete_at(randomizer.rand * cards.length))
-          end
+          pick_if_available! while picks.length != allocations && picker.length.positive?
+        end
+
+        def pick_if_available!
+          player = picker.pick
+          return if picker.player_counter[player] > game_week.player(player).supply(league, rarity).ceil
+
+          picks.push(player)
         end
 
         def reorder!
-          picks.sort! { |a, b| supply[a]['rank'].to_i <=> supply[b]['rank'].to_i }
+          picks.sort! do |a, b|
+            game_week.player(a).rank(league, rarity) <=> game_week.player(b).rank(league, rarity)
+          end
         end
 
         def check_length!

data/lib/sorare/rewards/interactors/cards/pick_for_game_week.rb

@@ -2,15 +2,12 @@
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/enumerable'
-require 'interactor'
-require 'yaml'
 
 module Sorare
   module Rewards
     module Cards
       # PickForGameWeek picks the rewards for a given game week
-      # Receive a Game Week reward supply data
-      #   { public_seed: 123, playing_players: [...], supply: {...} }
+      # Receive a Game Week object
       # And a reward allocations
       #    {
       #      'global-all_star' => {
@@ -22,16 +19,17 @@ module Sorare
       class PickForGameWeek
         include Interactor
 
-        delegate :supply, :allocations, :randomizer, :public_seed, :salt, to: :context
+        delegate :game_week, :allocations, :salt, :picks, to: :context
 
         def call
-          context.randomizer = Sorare::Rewards::Random.new(public_seed, salt)
           context.picks = picks
         end
 
         def picks
-          allocations.keys.index_with do |league|
-            PickForLeague.call!(**context.to_h, supply: supply[league], allocations: allocations[league]).league_picks
+          allocations.each_league_allocations.each_with_object({}) do |(league_name, league_allocations), picks|
+            picks[league_name] = PickForLeague.call!(
+              **context.to_h, league: game_week.league(league_name), allocations: league_allocations
+            ).league_picks
           end
         end
       end

data/lib/sorare/rewards/interactors/cards/pick_for_league.rb

@@ -2,19 +2,13 @@
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/enumerable'
-require 'interactor'
-require 'yaml'
 
 module Sorare
   module Rewards
     module Cards
       # PickForLeague picks the rewards for a given league
-      # Receive a game week league supply
-      #   {
-      #     'rare' => { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...},
-      #     'super_rare' => { 'kylian-mbappe-lottin' => { 'rank' => 1 }, ...}
-      #   }
-      # And a reward allocations
+      # Receive a game week object
+      # And a league allocations
       #   {
       #     'D1' => {
       #       'rare' => { 'tier_0' => 1, 'tier_1' => 2 }
@@ -23,40 +17,46 @@ module Sorare
       class PickForLeague
         include Interactor
 
-        delegate :supply, :allocations, :cards, to: :context
+        delegate :salt, :league, :allocations, :pickers, to: :context
+        delegate :game_week, to: :league
 
         def call
-          context.cards = {}
-          add_cards!
+          context.pickers = {}
+          add_pickers!
 
           context.league_picks = allocations.keys.index_with do |division|
             PickForDivision.call!(
-              **context.to_h, cards: cards, allocations: allocations[division]
+              **context.to_h, pickers: pickers, allocations: allocations[division]
             ).division_picks
           end
         end
 
-        def add_cards!
-          supply.keys.index_with do |rarity|
-            cards[rarity] = {}
+        def add_pickers!
+          league.supply.keys.index_with do |rarity|
+            pickers[rarity] = {}
             qualify_and_add!(rarity)
           end
         end
 
         def qualify_and_add!(rarity)
-          qualified_players = Tiers::QualifyPlayers.call!(sorted_supply: supply[rarity]).players
+          sorted_supply = league.supply[rarity]
+          qualified_players = Tiers::QualifyPlayers.call!(sorted_supply: sorted_supply).players
           qualified_players.each_with_index.map do |players, tier|
             transformed_tier = Sorare::Rewards.configuration.transform_tier.call(tier)
-            cards[rarity][transformed_tier] = []
+            initialize_tier_picker(players, rarity, transformed_tier)
+          end
+        end
+
+        def initialize_tier_picker(players, rarity, tier)
+          pickers[rarity][tier] = Picker.new(game_week.public_seed, salt)
 
-            players.each do |player_slug|
-              add(player_slug, rarity, transformed_tier)
-            end
+          players.each do |slug|
+            pickers[rarity][tier].add_player(slug, player_supply(league, rarity, slug))
           end
         end
 
-        def add(player_slug, rarity, tier)
-          cards[rarity][tier] += Array.new(supply[rarity][player_slug]['supply'], player_slug)
+        def player_supply(league, rarity, slug)
+          game_week.player(slug).overall_supply(league, rarity)
         end
       end
     end

data/lib/sorare/rewards/interactors/pick.rb

@@ -3,7 +3,6 @@
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards
@@ -20,15 +19,21 @@ module Sorare
     class Pick
       include Interactor
 
-      delegate :allocations, :data, :salt, to: :context
+      delegate :card_allocations, :game_week, :salt, to: :context
 
       # Depending on the way the allocations interpreter is implemented it could be done by him or we
       # update the allocations process to match the structure
       def call
         context.picks = Sorare::Rewards::Cards::PickForGameWeek.call!(
-          **data.to_h, salt: salt, allocations: Transposer.transpose_allocations(allocations)
+          **context.to_h,
+          salt: salt,
+          allocations: transposed_allocations
         ).picks
       end
+
+      def transposed_allocations
+        Sorare::Rewards::GameWeekAllocations.new(Transposer.transpose_allocations(card_allocations))
+      end
     end
   end
 end

data/lib/sorare/rewards/interactors/prize_pools/compute_for_division.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+
+module Sorare
+  module Rewards
+    module PrizePools
+      # ComputeForDivision computes the prize pools of a division
+      class ComputeForDivision
+        include Interactor
+
+        delegate :playing_rate, :available_prize_pools, to: :context
+
+        def call
+          context.division_prize_pools = available_prize_pools.map do |available_prize_pool|
+            available_prize_pool * percentage_rewarded
+          end
+        end
+
+        def percentage_rewarded
+          @percentage_rewarded ||= (config.find do |rate_config|
+            (rate_config.dig('playing_rates', 0)...rate_config.dig('playing_rates', 1)).include?(playing_rate)
+          end || config.last)['percentage_rewarded']
+        end
+
+        def config
+          Sorare::Rewards.configuration.prize_pool_configuration
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/prize_pools/compute_for_game_week.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/module/delegation'
+
+module Sorare
+  module Rewards
+    module PrizePools
+      # ComputeForGameWeek computes the prize pools of a game week
+      class ComputeForGameWeek
+        include Interactor
+
+        delegate :game_week, to: :context
+
+        def call
+          context.prize_pools = prize_pools!
+        end
+
+        def prize_pools!
+          game_week.each_league.each_with_object(Hash.new({})) do |league, game_week_prize_pools|
+            game_week_prize_pools[league.name] = ComputeForLeague.call!(league: league).league_prize_pools
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/prize_pools/compute_for_league.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+
+module Sorare
+  module Rewards
+    module PrizePools
+      # ComputeForLeague computes the prize pools of a league
+      class ComputeForLeague
+        include Interactor
+
+        delegate :league, to: :context
+
+        def call
+          context.league_prize_pools = prize_pools!
+        end
+
+        def prize_pools!
+          league.each_division_prize_pools.map do |division, prize_pools|
+            [
+              Sorare::Rewards.configuration.transform_division.call(division),
+              ComputeForDivision.call!(playing_rate: league.playing_rate, available_prize_pools: prize_pools)
+                                .division_prize_pools
+            ]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/interactors/supply/compute_for_game_week.rb

@@ -2,7 +2,6 @@
 
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards
@@ -11,16 +10,28 @@ module Sorare
       class ComputeForGameWeek
         include Interactor
 
-        delegate :public_seed, :salt, :supply, :playing_players, :game_week_supply, to: :context
+        delegate :salt, :game_week, :game_week_supply, to: :context
 
         def call
-          context.game_week_supply = supply.keys.index_with do |league|
-            ComputeForLeague.call!(**context.to_h, randomizer: randomizer, supply: supply[league]).league_supply
+          context.game_week_supply = game_week_supply!
+        end
+
+        def game_week_supply!
+          game_week.each_league.each_with_object(Hash.new({})) do |league, game_week_supply|
+            game_week_supply[league.name] = league_supply!(league)
+          end
+        end
+
+        def league_supply!(league)
+          league.each_rarity_supply.each_with_object({}) do |(rarity, supply), league_supply|
+            league_supply[rarity] = ComputeForRarity.call!(
+              league: league, rarity: rarity, supply: supply, randomizer: randomizer
+            ).rarity_supply
           end
         end
 
         def randomizer
-          @randomizer ||= Sorare::Rewards::Random.new(public_seed, salt)
+          @randomizer ||= Sorare::Rewards::Random.new(game_week.public_seed, salt)
         end
       end
     end

data/lib/sorare/rewards/interactors/supply/compute_for_quality.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards

data/lib/sorare/rewards/interactors/supply/compute_for_rarity.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards
@@ -11,8 +9,9 @@ module Sorare
       class ComputeForRarity
         include Interactor
 
-        delegate :randomizer, :supply, :playing_players, :rewardable, :rarity_supply,
+        delegate :randomizer, :league, :rarity, :supply, :rewardable, :rarity_supply,
                  :minimum_remaining_games, to: :context
+        delegate :game_week, to: :league
 
         def call
           context.rarity_supply = []
@@ -22,7 +21,7 @@ module Sorare
         end
 
         def compute_rewardable_supply!
-          total_supply = playing_players.keys.sum do |player|
+          total_supply = supply.keys.sum do |player|
             player_supply(player)
           end
 
@@ -45,22 +44,13 @@ module Sorare
         end
 
         def player_supply(slug)
-          remaining_games = playing_players[slug] || 0
-          return 0 unless remaining_games.positive?
-          return 0 unless supply[slug]
-
-          supply[slug]['supply'].to_f / corrected_remaining_games(remaining_games)
+          game_week.player(slug).supply(league, rarity)
         end
 
         def rounded_supply(float_supply)
           float_supply.floor + remaining_supply(float_supply.modulo(1))
         end
 
-        # To be improved to handle properly seasons overlap
-        def corrected_remaining_games(remaining_games)
-          [remaining_games, minimum_remaining_games || 10].max
-        end
-
         def remaining_supply(reward_probability)
           probability = randomizer.rand
           return 0 unless probability < reward_probability

data/lib/sorare/rewards/interactors/tiers/qualify_players.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards
@@ -19,9 +18,9 @@ module Sorare
 
         # Use the tier specified within the data
         def qualified_players_by_tier
-          tiers = Sorare::Rewards.configuration.tiers.times.map { |_| [] }
+          tiers = Sorare::Rewards.configuration.tiers.times.map { |_| {} }
           sorted_supply.each do |slug, data|
-            tiers[data['tier']] << slug
+            tiers[data['tier']][slug] = data
           end
 
           tiers

data/lib/sorare/rewards/interactors/tiers/qualify_supply.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/module/delegation'
-require 'interactor'
 
 module Sorare
   module Rewards

data/lib/sorare/rewards/league.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Sorare
+  module Rewards
+    # League stores the reward config for a league
+    class League
+      attr_reader :name, :supply, :config, :game_week
+
+      delegate :salt, to: :game_week
+
+      def initialize(name:, config:, supply:, game_week:)
+        @name = name
+        @config = config
+        @supply = supply
+        @game_week = game_week
+      end
+
+      %w[playing_rate prize_pools].each do |key|
+        define_method(key) do
+          config[key]
+        end
+      end
+
+      def each_division_prize_pools
+        prize_pools.each_with_index do |prize_pool, index|
+          return to_enum(:each_division_prize_pools) unless block_given?
+
+          yield(index + 1, prize_pool)
+        end
+      end
+
+      def each_rarity_supply
+        supply.each_key do |rarity|
+          return to_enum(:each_rarity_supply) unless block_given?
+
+          yield(rarity, supply[rarity])
+        end
+      end
+
+      def each_rarity_tier_supply
+        each_rarity_supply do |rarity, rarity_supply|
+          qualified_supply = Tiers::QualifyPlayers.call!(sorted_supply: rarity_supply).players
+          qualified_supply.each_key.map do |tier|
+            return to_enum(:each_rarity_tier_supply) unless block_given?
+
+            transformed_tier = Sorare::Rewards.configuration.transform_tier.call(tier)
+            yield(rarity, transformed_tier, qualified_supply[tier])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/picker.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+
+module Sorare
+  module Rewards
+    # Picker allows to randomly pick a card
+    class Picker
+      attr_accessor :cards, :player_counter
+
+      delegate :length, to: :cards
+
+      def initialize(seed, salt)
+        @random = Random.new(seed, salt)
+        @cards = []
+        @player_counter = Hash.new(0)
+        @shuffled = false
+      end
+
+      def add_player(slug, count)
+        raise "Can't add a player to a started draw" if @shuffled
+
+        @cards += Array.new(count, slug)
+      end
+
+      def pick
+        shuffle! unless @shuffled
+
+        @cards.shift.tap do |card|
+          @player_counter[card] += 1 if card
+        end
+      end
+
+      def shuffle!
+        @cards.shuffle!(random: @random)
+        @shuffled = true
+      end
+    end
+  end
+end

data/lib/sorare/rewards/player.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'time'
+
+module Sorare
+  module Rewards
+    # Player stores the reward data of a player for a game week
+    class Player
+      attr_reader :slug
+
+      def initialize(slug, reward_data)
+        @slug = slug
+        @supply = Hash.new { |h, k| h[k] = {} }
+        @config = reward_data.config
+        @game_data = reward_data.playing_players[slug]
+        load_supply(reward_data)
+      end
+
+      def rewardable?(league, rarity)
+        !@config.cooldown?(rarity, @game_data.dig(league, rarity) || [])
+      end
+
+      def playing?
+        @game_data.present?
+      end
+
+      def supply(league, rarity)
+        return 0 unless playing? && remaining_games_for_supply.positive?
+
+        [
+          uncapped_supply_for_game_week(league, rarity), # Remaining supply
+          available_during_cooldown(league, rarity), # Cooldown limit
+          @config.distribution_limit(rarity) # Hard limit
+        ].min
+      end
+
+      def rank(league, rarity)
+        @supply.dig(league.name, rarity, 'rank')
+      end
+
+      def overall_supply(league, rarity)
+        @supply.dig(league.name, rarity, 'supply') || 0
+      end
+
+      def uncapped_supply_for_game_week(league, rarity)
+        overall_supply(league, rarity) / remaining_games_for_supply.to_f
+      end
+
+      def available_during_cooldown(league, rarity)
+        [@config.cooldown_limit(rarity) - rewarded_during_cooldown(league, rarity), 0].max
+      end
+
+      def rewarded_during_cooldown(league, rarity)
+        (rewards&.dig(league) || []).count { |at| (Time.parse(at) + @config.cooldown_since(rarity)) < Time.now }
+      end
+
+      %w[rewards remaining_games_for_supply remaining_games].each do |key|
+        define_method(key) do
+          @game_data&.dig(key)
+        end
+      end
+
+      private
+
+      def load_supply(reward_data)
+        reward_data.each_league do |league|
+          league.each_rarity_supply do |rarity, supply|
+            next unless supply[slug]
+
+            @supply[league.name][rarity] = supply[slug]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorare/rewards/prize_pool_configuration.yml

@@ -0,0 +1,9 @@
+rates:
+  - playing_rates: [0, 0.1]
+    percentage_rewarded: 0.25
+  - playing_rates: [0.1, 0.2]
+    percentage_rewarded: 0.5
+  - playing_rates: [0.2, 0.3]
+    percentage_rewarded: 0.75
+  - playing_rates: [0.3, 1]
+    percentage_rewarded: 1

data/lib/sorare/rewards/version.rb

@@ -2,6 +2,6 @@
 
 module Sorare
   module Rewards
-    VERSION = '0.1.0.beta11'
+    VERSION = '1.0.0.beta4'
   end
 end

data/lib/sorare/rewards.rb

@@ -21,15 +21,6 @@ module Sorare
       end
     end
 
-    def self.game_week_data(hash)
-      uri = URI("#{configuration.gateway}#{hash}")
-      JSON.parse(::Net::HTTP.get(uri))
-    end
-
-    def self.build_rewards(salt:, hash: nil, data: nil)
-      Sorare::Rewards::Build.call!(data: data || game_week_data(hash), salt: salt).allocations
-    end
-
     def self.pick(salt:, hash: nil, data: nil)
       allocation_ctx = Sorare::Rewards::Build.call!(data: data || game_week_data(hash), salt: salt)
       Sorare::Rewards::Pick.call!(allocation_ctx.to_h).picks

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorare-rewards
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta11
+  version: 1.0.0.beta4
 platform: ruby
 authors:
 - pierre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-06-02 00:00:00.000000000 Z
+date: 2021-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -168,9 +168,14 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- data.patch
 - lib/sorare/rewards.rb
 - lib/sorare/rewards/allocation_configuration.yml
 - lib/sorare/rewards/configuration.rb
+- lib/sorare/rewards/game_week.rb
+- lib/sorare/rewards/game_week_allocations.rb
+- lib/sorare/rewards/game_week_config.rb
+- lib/sorare/rewards/interactor.rb
 - lib/sorare/rewards/interactors/allocations/compute_for_game_week.rb
 - lib/sorare/rewards/interactors/allocations/compute_for_league.rb
 - lib/sorare/rewards/interactors/allocations/compute_for_quality.rb
@@ -182,12 +187,18 @@ files:
 - lib/sorare/rewards/interactors/cards/pick_for_game_week.rb
 - lib/sorare/rewards/interactors/cards/pick_for_league.rb
 - lib/sorare/rewards/interactors/pick.rb
+- lib/sorare/rewards/interactors/prize_pools/compute_for_division.rb
+- lib/sorare/rewards/interactors/prize_pools/compute_for_game_week.rb
+- lib/sorare/rewards/interactors/prize_pools/compute_for_league.rb
 - lib/sorare/rewards/interactors/supply/compute_for_game_week.rb
-- lib/sorare/rewards/interactors/supply/compute_for_league.rb
 - lib/sorare/rewards/interactors/supply/compute_for_quality.rb
 - lib/sorare/rewards/interactors/supply/compute_for_rarity.rb
 - lib/sorare/rewards/interactors/tiers/qualify_players.rb
 - lib/sorare/rewards/interactors/tiers/qualify_supply.rb
+- lib/sorare/rewards/league.rb
+- lib/sorare/rewards/picker.rb
+- lib/sorare/rewards/player.rb
+- lib/sorare/rewards/prize_pool_configuration.yml
 - lib/sorare/rewards/random.rb
 - lib/sorare/rewards/transposer.rb
 - lib/sorare/rewards/version.rb

data/lib/sorare/rewards/interactors/supply/compute_for_league.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/module/delegation'
-require 'interactor'
-
-module Sorare
-  module Rewards
-    module Supply
-      # ComputeForLeague computes the rewardable supply of a league
-      class ComputeForLeague
-        include Interactor
-
-        delegate :randomizer, :supply, :playing_players, to: :context
-
-        def call
-          context.league_supply = supply.keys.index_with do |rarity|
-            ComputeForRarity.call!(**context.to_h, supply: supply[rarity]).rarity_supply
-          end
-        end
-      end
-    end
-  end
-end