steam-trade 0.3.0 → 0.3.1

data/lib/Confirmation.rb

@@ -86,7 +86,7 @@ module ConfirmationCommands
 
       def send_confirmation(confirmationhash) ## tenth
             tag = 'allow'
-            params = create_confirmation_params(tag) ## EXISTS
+            params = create_confirmation_params('conf') ## EXISTS
             params['op'] = tag
             params['cid'] = confirmationhash["data_confid"]
             params['ck'] = confirmationhash["data_key"]

data/lib/EventCards.rb

@@ -106,7 +106,7 @@ module EventCommands
                         'origin' => 'https://steamcommunity.com',
                         'referer' => 'https://steamcommunity.com/saliengame/play/'
                   }
-                  
+
                   params = {
                       'gameid' => active_game,
                       'access_token' => game_token
@@ -154,4 +154,92 @@ module EventCommands
       end
 
 
+      def cottage()
+        raise "must be logged in to use the command" if @logged == false
+
+        door_ids = []
+        Nokogiri::HTML(@session.get('https://store.steampowered.com/promotion/cottage_2018/').content).css('#alldoors_container').css('.cottage_doorset').each { |door|
+          next if door["class"].include?('cottage_door_open')
+          door_ids << door['data-door-id']
+        }
+
+        if door_ids.empty?
+          puts "There are no door to open for #{@username}"
+          return
+        end
+
+
+        door_ids.each { |id|
+
+
+          timestamp = Time.new.strftime("%Y-%m-%dT%H:%M:%S")
+
+          post_params = {
+            'sessionid' => store_cookie(),
+            'door_index' => id,
+            't' => timestamp,
+            'open_door' => true
+          }
+
+          post_headers = {
+            'Origin' => 'https://store.steampowered.com',
+            'Referer' => 'https://store.steampowered.com/promotion/cottage_2018/',
+            'User-Agent' => 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 OPR/57.0.3098.102',
+            'X-Requested-With' => 'XMLHttpRequest'
+          }
+
+          @session.post('https://store.steampowered.com/promotion/opencottagedoorajax' , post_params, post_headers)
+
+        }
+
+      end
+
+      def vote_2018()
+        text = @session.get('https://store.steampowered.com/SteamAwards/2018/').content
+        Nokogiri::HTML(text).css('.steamaward_categories_ctn')[0].css('.vote_category_bg').each { |container|
+          container['']
+          title = container.css(".category_title")[0].text.downcase
+          voteid = container.css(".category_nominations_ctn")[0]["data-voteid"]
+
+          nominees = []
+          voted = false
+          i = 1
+          container.css(".category_nomination").each { |nom|
+            (voted = true; break;) if nom["class"].include?('grayed_out_nomination')
+
+            nominees << nom["data-vote-appid"]
+          }
+          next if voted
+          (File.open('./error.html', 'w') {|f| f.puts text}; raise "no nominees selected if";) if nominees.compact!.empty?
+          appid = nominees[rand(nominees.length - 1)]
+
+
+          params = {
+            'voteid' => voteid,
+            'sessionid' => store_cookie(),
+          }
+          puts "voting for #{title}"
+          if title.include?('developer')
+            puts "switching sides"
+            params['appid'] = 0
+            params['developerid'] = appid
+          else
+            params['appid'] = appid
+            params['developerid'] = 0
+          end
+          post_headers = {
+            'Origin' => 'https://store.steampowered.com',
+            'Referer' => 'https://store.steampowered.com/SteamAwards/2018/',
+            'User-Agent' => 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 OPR/57.0.3098.102',
+            'X-Requested-With' => 'XMLHttpRequest'
+          }
+          @session.post('https://store.steampowered.com/salevote', params, post_headers)
+          puts "voted for #{title}"
+          sleep(2)
+
+        }
+
+
+      end
+
 end

data/lib/Guard.rb

@@ -72,9 +72,13 @@ module GuardCommands
 
 
       def generate_device_id()
-            hexed = Digest::SHA1.hexdigest(@steamid.to_s)
-            res = 'android:' + [hexed[0..7],hexed[8..11],hexed[12..15],hexed[16..19],hexed[20..31]].join('-')
-            return res
+            if @android_id.nil?
+                  hexed = Digest::SHA1.hexdigest(@steamid.to_s)
+                  res = 'android:' + [hexed[0..7],hexed[8..11],hexed[12..15],hexed[16..19],hexed[20..31]].join('-')
+                  return res
+            else
+                  return @android_id
+            end
       end
 
 end

data/lib/LoginExecutor.rb

@@ -1,156 +1,156 @@
-module LoginCommands
-
-########################################################################################
-     private
-      def login()
-            response = @session.post('https://store.steampowered.com/login/getrsakey/', {'username' => @username}).content
-            data = pass_stamp(response,@password)
-            encrypted_password = data["password"]
-            timestamp = data["timestamp"]
-            repeater = 0
-
-
-            send = {
-                  'password' => encrypted_password,
-                  'username' => @username,
-                  'twofactorcode' =>'', #update
-                  'emailauth' => '',
-                  'loginfriendlyname' => '',
-                  'captchagid' => '-1',
-                  'captcha_text' => '',
-                  'emailsteamid' => '',
-                  'rsatimestamp' => timestamp,
-                  'remember_login' => @remember
-            }
-            login = @session.post('https://store.steampowered.com/login/dologin', send ).content
-            firstreq = JSON.parse(login)
-
-            raise "Incorrect username or password" if firstreq["message"] == "The account name or password that you have entered is incorrect."
-
-
-            until firstreq["success"] == true
-                  sleep(0.3)
-                  gid = '-1'
-                  cap = ''
-                  if firstreq['captcha_needed'] == true
-                        gid = firstreq['captcha_needed']
-                        File.delete("./#{username}_captcha.png") if File.exist?("./#{username}_captcha.png")
-                        @session.get("https://store.steampowered.com/login/rendercaptcha?gid=#{gid}").save "./#{@username}_captcha.png"
-                        puts "you need to write a captcha to continue"
-                        puts "there is an image named #{@username}_captcha in the script directory"
-                        puts "open it and write the captha here"
-                        cap = gets.chomp
-                  end
-                  emailauth = ''
-                  facode = ''
-                  emailsteamid = ''
-                  if firstreq['requires_twofactor'] == true
-                        if @secret.nil?
-                              puts "write 2FA code"
-                              facode = gets.chomp
-                        else
-                              facode = fa(@secret,@time_difference)
-                        end
-                  elsif firstreq['emailauth_needed'] == true
-                        emailsteamid = firstreq['emailsteamid']
-                        puts "Guard code was sent to your email"
-                        puts "write the code"
-                        emailauth = gets.chomp
-                  end
-
-                  send = {
-                        'password' => encrypted_password,
-                        'username' => @username,
-                        'twofactorcode' => facode, #update
-                        'emailauth' => emailauth,
-                        'loginfriendlyname' => '',
-                        'captchagid' => gid,
-                        'captcha_text' => cap,
-                        'emailsteamid' => emailsteamid,
-                        'rsatimestamp' => timestamp,
-                        'remember_login' => @remember
-                  }
-                  output "attempting to login"
-                  login = @session.post('https://store.steampowered.com/login/dologin', send ).content
-                  firstreq = JSON.parse(login)
-
-            end
-            response = firstreq
-
-
-
-
-
-            if @steamid != nil && @steamid != response["transfer_parameters"]["steamid"]
-                  puts "the steamid you provided does not belong to the account you entered"
-                  puts "steamid will be overwritten"
-                  @steamid = response["transfer_parameters"]["steamid"]
-
-            else
-                  @steamid = response["transfer_parameters"]["steamid"]
-            end
-
-
-            response["transfer_urls"].each { |url|
-                  @session.post(url, response["transfer_parameters"])
-            }
-
-
-
-            steampowered_sessionid = ''
-            @session.cookies.each { |c|
-                  if c.name == "sessionid"
-                         steampowered_sessionid = c.value
-                   end
-            }
-
-            cookie = Mechanize::Cookie.new :domain => 'steamcommunity.com', :name =>'sessionid', :value =>steampowered_sessionid, :path => '/'
-            @session.cookie_jar << cookie
-            @loggedin = true
-            begin
-                  text = Nokogiri::HTML(@session.get("https://steamcommunity.com/dev/apikey").content).css('#bodyContents_ex').css('p').first.text.sub('Key: ','')
-                  if text.include?('Registering for a Steam Web API Key will enable you to access many Steam features from your own website') == false
-                        @api_key = text
-                  end
-            rescue
-                  output "Could not retrieve api_key"
-            end
-
-            if !@api_key.nil?
-                  data = get_player_summaries(@steamid) if !@api_key.nil?
-                  data.each { |element|
-                        if element["steamid"].to_s == @steamid.to_s
-                              @persona = element["personaname"]
-                        end
-                  }
-            end
-            output "logged in as #{@persona}"
-            output "your steamid is #{@steamid}"
-            output "loaded API_KEY : #{@api_key}" if !@api_key.nil?
-      end
-########################################################################################
-
-
-########################################################################################
-      def pass_stamp(give,password)
-
-            data = JSON::parse(give)
-            mod = data["publickey_mod"].hex
-            exp = data["publickey_exp"].hex
-            timestamp = data["timestamp"]
-
-            key   = OpenSSL::PKey::RSA.new
-            if RUBY_VERSION.to_f <= 2.3
-                  key.e = OpenSSL::BN.new(exp)
-                  key.n = OpenSSL::BN.new(mod)
-            elsif RUBY_VERSION.to_f >= 2.4
-                  #key.set_key(n, e, d)
-                  key.set_key(OpenSSL::BN.new(mod), OpenSSL::BN.new(exp),nil)
-            end
-            ep = Base64.encode64(key.public_encrypt(password.force_encoding("utf-8"))).gsub("\n", '')
-            return {'password' => ep, 'timestamp' => timestamp }
-      end
-########################################################################################
-
-
-end
+module LoginCommands
+
+########################################################################################
+     private
+      def login()
+            response = @session.post('https://store.steampowered.com/login/getrsakey/', {'username' => @username}).content
+            data = pass_stamp(response,@password)
+            encrypted_password = data["password"]
+            timestamp = data["timestamp"]
+            repeater = 0
+
+
+            send = {
+                  'password' => encrypted_password,
+                  'username' => @username,
+                  'twofactorcode' =>'', #update
+                  'emailauth' => '',
+                  'loginfriendlyname' => '',
+                  'captchagid' => '-1',
+                  'captcha_text' => '',
+                  'emailsteamid' => '',
+                  'rsatimestamp' => timestamp,
+                  'remember_login' => @remember
+            }
+            login = @session.post('https://store.steampowered.com/login/dologin', send ).content
+            firstreq = JSON.parse(login)
+
+            raise "Incorrect username or password" if firstreq["message"] == "The account name or password that you have entered is incorrect."
+
+
+            until firstreq["success"] == true
+                  sleep(0.3)
+                  gid = '-1'
+                  cap = ''
+                  if firstreq['captcha_needed'] == true
+                        gid = firstreq['captcha_needed']
+                        File.delete("./#{username}_captcha.png") if File.exist?("./#{username}_captcha.png")
+                        @session.get("https://store.steampowered.com/login/rendercaptcha?gid=#{gid}").save "./#{@username}_captcha.png"
+                        puts "you need to write a captcha to continue"
+                        puts "there is an image named #{@username}_captcha in the script directory"
+                        puts "open it and write the captha here"
+                        cap = gets.chomp
+                  end
+                  emailauth = ''
+                  facode = ''
+                  emailsteamid = ''
+                  if firstreq['requires_twofactor'] == true
+                        if @secret.nil?
+                              puts "write 2FA code"
+                              facode = gets.chomp
+                        else
+                              facode = fa(@secret,@time_difference)
+                        end
+                  elsif firstreq['emailauth_needed'] == true
+                        emailsteamid = firstreq['emailsteamid']
+                        puts "Guard code was sent to your email"
+                        puts "write the code"
+                        emailauth = gets.chomp
+                  end
+
+                  send = {
+                        'password' => encrypted_password,
+                        'username' => @username,
+                        'twofactorcode' => facode, #update
+                        'emailauth' => emailauth,
+                        'loginfriendlyname' => '',
+                        'captchagid' => gid,
+                        'captcha_text' => cap,
+                        'emailsteamid' => emailsteamid,
+                        'rsatimestamp' => timestamp,
+                        'remember_login' => @remember
+                  }
+                  output "attempting to login"
+                  login = @session.post('https://store.steampowered.com/login/dologin', send ).content
+                  firstreq = JSON.parse(login)
+
+            end
+            response = firstreq
+
+
+
+
+
+            if @steamid != nil && @steamid != response["transfer_parameters"]["steamid"]
+                  puts "the steamid you provided does not belong to the account you entered"
+                  puts "steamid will be overwritten"
+                  @steamid = response["transfer_parameters"]["steamid"]
+
+            else
+                  @steamid = response["transfer_parameters"]["steamid"]
+            end
+
+
+            response["transfer_urls"].each { |url|
+                  @session.post(url, response["transfer_parameters"])
+            }
+
+
+
+            steampowered_sessionid = ''
+            @session.cookies.each { |c|
+                  if c.name == "sessionid"
+                         steampowered_sessionid = c.value
+                   end
+            }
+
+            cookie = Mechanize::Cookie.new :domain => 'steamcommunity.com', :name =>'sessionid', :value =>steampowered_sessionid, :path => '/'
+            @session.cookie_jar << cookie
+            @loggedin = true
+            begin
+                  text = Nokogiri::HTML(@session.get("https://steamcommunity.com/dev/apikey").content).css('#bodyContents_ex').css('p').first.text.split(' ')
+                  if text.include?('Registering for a Steam Web API Key will enable you to access many Steam features from your own website') == false
+                        @api_key = text[1]
+                  end
+            rescue
+                  output "Could not retrieve api_key"
+            end
+
+            if !@api_key.nil?
+                  data = get_player_summaries(@steamid) if !@api_key.nil?
+                  data.each { |element|
+                        if element["steamid"].to_s == @steamid.to_s
+                              @persona = element["personaname"]
+                        end
+                  }
+            end
+            output "logged in as #{@persona}"
+            output "your steamid is #{@steamid}"
+            output "loaded API_KEY : #{@api_key}" if !@api_key.nil?
+      end
+########################################################################################
+
+
+########################################################################################
+      def pass_stamp(give,password)
+
+            data = JSON::parse(give)
+            mod = data["publickey_mod"].hex
+            exp = data["publickey_exp"].hex
+            timestamp = data["timestamp"]
+
+            key   = OpenSSL::PKey::RSA.new
+            if RUBY_VERSION.to_f <= 2.3
+                  key.e = OpenSSL::BN.new(exp)
+                  key.n = OpenSSL::BN.new(mod)
+            elsif RUBY_VERSION.to_f >= 2.4
+                  #key.set_key(n, e, d)
+                  key.set_key(OpenSSL::BN.new(mod), OpenSSL::BN.new(exp),nil)
+            end
+            ep = Base64.encode64(key.public_encrypt(password.force_encoding("utf-8"))).gsub("\n", '')
+            return {'password' => ep, 'timestamp' => timestamp }
+      end
+########################################################################################
+
+
+end

data/lib/Trade.rb

@@ -65,9 +65,11 @@ module TradeCommands
                         sleep(0.6)
                         responsehash = response.merge(send_trade_allow_request(response["tradeofferid"]))
                         output "offer confirmed " + response["tradeofferid"]
+                        return responsehash
                   else
                         output "cannot confirm trade automatically, no shared secret given"
                         output "Manual confirmation is needed"
+                        return nil
                   end
             end
 
@@ -90,8 +92,42 @@ module TradeCommands
 
 
 
+      def sell_items(items, price)
+        raise "no account logged in, #{self} " if @loggedin == false
+        raise "Must given array" if items.class != Array
 
 
+        headers = {
+              'Origin' => 'https://steamcommunity.com',
+              'Referer' => 'https://steamcommunity.com/id/SimplifiedPact/inventory/',
+              'User-Agent' => 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Safari/537.36 OPR/54.0.2952.54',
+        }
+        
+        items.each { |asset|
+
+          asset['sessionid'] = sessionid_cookie()
+          asset['price'] = price
+          verd = {'sucess' => false}
+          tries = 0
+          i = 0
+          until verd['success'] == true || tries == 2
+                resp = @session.post('https://steamcommunity.com/market/sellitem/', asset, headers)
+
+                verd = JSON.parse(resp.content)
+
+                if verd['success'] == false
+                      break if verd['message'].include?('You already have a listing for this') || verd['message'].include?('We were unable to contact')
+                      tries += 1
+                      sleep(10)
+                else
+                  i += 1
+                  puts "#{i} / #{items.length} sold"
+                end
+          end
+          sleep(1)
+        }
+      end
+