def tradeautorize():
time.sleep(40)
steam_client = SteamClient('#')
print('ok1')
steam_client.login('#', '#', 'D:\CsMoney\Steamguard.txt')
steam_client = SteamClient('#')
print('ok1')
steam_client.login('#', '#', 'D:\CsMoney\Steamguard.txt')
print('logged')
while True:
try:
received_offers = steam_client.get_trade_offers(True)
response = received_offers['response']
trade_offers_received = response.get('trade_offers_received')
for i in trade_offers_received:
tradeoffer_id = i.get('tradeofferid')
message = i.get('message')
if message == 'Automatically generated from CS.MONEY' or 'This is an automatic trade generated by OPSkins. Security token' in message:
print(message)
steam_client.accept_trade_offer(tradeoffer_id)
else:
continue
except:
continue
class Client:
def __init__(self):
self.client = SteamClient(api_key)
def login(self):
self.client.login(username, password, dumps(secrets))
if self.client.was_login_executed:
log.info(f'Logged into Steam as {f.GREEN + username}')
else:
log.error('Login was not executed')
def logut(self):
log.info('Logging out...')
self.client.logout()
def get_offers(self):
return self.client.get_trade_offers(merge=True)['response']['trade_offers_received']
def get_offer(self, offer_id):
return self.client.get_trade_offer(offer_id, merge=True)['response']['offer']
def get_receipt(self, trade_id):
return self.client.get_trade_receipt(trade_id)
def accept(self, offer_id: str):
log.trade('Trying to accept offer', offer_id)
self.client.accept_trade_offer(offer_id)
def decline(self, offer_id: str):
log.trade('Trying to decline offer', offer_id)
self.client.decline_trade_offer(offer_id)
def post_confirmation(steamid, api, val, trade_id):
user = user_conf(steamid)
try:
try:
client = steam_session[steamid]
print("use steampy cache")
except:
print("use steampy login")
g = user["guard"]
g["steamid"] = steamid
Sguard = json.dumps(g)
client = SteamClient(api)
client.login(user["name"], user["password"], Sguard)
globals()["steam_session"][steamid] = client
if (val):
try:
client._confirm_transaction(trade_id)
except:
client.accept_trade_offer(trade_id)
else:
client.cancel_trade_offer(trade_id)
client.decline_trade_offer(trade_id)
return {"success": True}
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
return {
"success": False,
"err_type": e.__class__.__name__,
"err_info": e.args[0],
"err_line": str(exc_tb.tb_lineno)
}
class Client:
def __init__(self, bot: dict):
self.log = Log(bot["name"])
self.username = bot["username"]
self.password = bot["password"]
self.secrets = bot["secrets"]
self.client = SteamClient(bot["api_key"])
def login(self) -> None:
try:
self.client.login(self.username, self.password,
dumps(self.secrets))
if self.client.was_login_executed:
self.log.info(
f"Logged into Steam as {f.GREEN + self.username}")
else:
self.log.error("Login was not executed")
except InvalidCredentials as e:
self.log.error(e)
def logout(self) -> None:
self.log.info("Logging out...")
self.client.logout()
def get_offers(self) -> dict:
try:
return self.client.get_trade_offers(
merge=True)["response"]["trade_offers_received"]
except KeyError:
return {}
def get_offer(self, offer_id: str) -> dict:
try:
return self.client.get_trade_offer(offer_id,
merge=True)["response"]["offer"]
except KeyError:
return {}
def get_receipt(self, trade_id: str) -> dict:
return self.client.get_trade_receipt(trade_id)
def accept(self, offer_id: str) -> None:
self.log.trade("Trying to accept offer", offer_id)
self.client.accept_trade_offer(offer_id)
def decline(self, offer_id: str) -> None:
self.log.trade("Trying to decline offer", offer_id)
self.client.decline_trade_offer(offer_id)
def test_accept_trade_offer(self):
client = SteamClient(self.credentials.api_key)
client.login(self.credentials.login, self.credentials.password,
self.steam_guard_file)
trade_offer_id = '1451378159'
response_dict = client.accept_trade_offer(trade_offer_id)
self.assertIsNotNone(response_dict)
def main():
print('This is the donation bot accepting items for free.')
if not are_credentials_filled():
print('You have to fill credentials in storehouse.py file to run the example')
print('Terminating bot')
return
client = SteamClient(api_key)
client.login(username, password, steamguard_path)
print('Bot logged in successfully, fetching offers every 60 seconds')
while True:
offers = client.get_trade_offers()['response']['trade_offers_received']
for offer in offers:
if is_donation(offer):
offer_id = offer['tradeofferid']
num_accepted_items = len(offer['items_to_receive'])
client.accept_trade_offer(offer_id)
print('Accepted trade offer {}. Got {} items'.format(offer_id, num_accepted_items))
time.sleep(60)
def main():
print('This is the donation bot accepting items for free.')
if not are_credentials_filled():
print(
'You have to fill credentials in storehouse.py file to run the example'
)
print('Terminating bot')
return
client = SteamClient(api_key)
client.login(username, password, steamguard_path)
print('Bot logged in successfully, fetching offers every 60 seconds')
while True:
offers = client.get_trade_offers()['response']['trade_offers_received']
for offer in offers:
if is_donation(offer):
offer_id = offer['tradeofferid']
num_accepted_items = len(offer['items_to_receive'])
client.accept_trade_offer(offer_id)
print('Accepted trade offer {}. Got {} items'.format(
offer_id, num_accepted_items))
time.sleep(60)
class BotTrade:
def __init__(self, col):
self.user = col['username']
self.psw = col['password']
self.apikey = col['dev_key']
self.guard_info = {
"steamid": str(col['steam_id']),
"shared_secret": col['configs']['shared_secret'],
"identity_secret": col['configs']['identity_secret'],
}
self.steam_client = SteamClient(self.apikey)
self.steam_client.login(self.user, self.psw, json.dumps(self.guard_info))
def send_all_items(self, trade_url, max_for_offer=300):
my_asset_list = self.get_all_tradable_assetid()
offer_id_list = []
while my_asset_list:
send_asset_list = my_asset_list[:max_for_offer]
del my_asset_list[:max_for_offer]
resp_dict = self.steam_client.make_offer_with_url(send_asset_list, [], trade_url, '')
print(resp_dict)
offer_id_list.append(resp_dict['tradeofferid'])
time.sleep(10)
return offer_id_list
def send_all_items_to_many(self, trade_url_list):
result = []
my_asset_list = self.get_all_tradable_assetid()
count = len(my_asset_list) // len(trade_url_list) # 整除
for index, value in enumerate(trade_url_list):
if index == len(trade_url_list) - 1:
data = my_asset_list[count * index:]
else:
data = my_asset_list[count * index:count * (index + 1)]
resp_dict = self.steam_client.make_offer_with_url(data, [], value, '')
result.append((value, resp_dict['tradeofferid']))
return result
def accept(self, trade_offer_id):
resp = self.steam_client.accept_trade_offer(trade_offer_id)
print('Accept trade', resp)
if 'tradeid' in resp:
return True
return False
def get_all_tradable_assetid(self):
game = GameOptions.DOTA2
my_items = self.steam_client.get_my_inventory_by_eshao(game)
my_asset_list = []
for i in my_items:
if i['tradable'] == 1:
my_asset_list.append(Asset(i['assetid'], game))
return my_asset_list
def executeTrade(u1, u2, item_ID):
success = False
MY_API_KEY = os.environ['MY_API_KEY']
PATH_TO_STEAMGUARD_FILE = os.environ['PATH_TO_STEAMGUARD_FILE']
OFFER_NAME = getTradeID(u1, u2, item_ID)
u1_username = u1.steam
u1_password = u1.pwd
u1_id = u1.steam_ID
u2_username = u2.steam
u2_password = u2.pwd
u2_id = u2.steam_ID
steam_client_u1 = SteamClient(MY_API_KEY)
steam_client_u1.login(u1_username, u1_password, PATH_TO_STEAMGUARD_FILE)
steam_client_u2 = SteamClient(MY_API_KEY)
steam_client_u2.login(u2_username, u2_password, PATH_TO_STEAMGUARD_FILE)
game = GameOptions.CS
my_items = steam_client_u1.get_my_inventory(game)
partner_items = steam_client_u1.get_partner_inventory(u2_id, game)
my_first_item = next(iter(my_items.values()))
partner_first_item = next(iter(partner_items.values()))
my_asset = Asset(my_first_item['id'], game)
partner_asset = Asset(partner_first_item['id'], game)
retDict = steam_client_u1.make_offer([my_asset], [partner_asset],
partner_id, OFFER_NAME)
if retDict:
tradeofferid = retDict['tradeofferid']
steam_client_u2.accept_trade_offer(tradeofferid)
success = True # return success
steam_client_u1.logout()
steam_client_u2.logout()
return success
def main():
data = json.loads(request.data.decode('utf-8'))
login, passwd, api_key = data['acc_data'][:3]
volume = int(data['acc_data'][4])
active_accs.setdefault(login, {})
mafile = data['mafile']
proxy_id = data['proxy_id']
steam_client = active_accs[login].get('steam_client')
if not steam_client:
steam_client = SteamClient(api_key, proxy=proxy)
r = steam_client.session.get('http://httpbin.org/ip')
logger.info(r.text)
steam_client.login(login, passwd, mafile)
active_accs[login]['steam_client'] = steam_client
offers = steam_client.get_trade_offers(
)['response']['trade_offers_received']
if offers:
while True:
resp = steam_client.accept_trade_offer(offers[0]['tradeofferid'],
proxy_id)
logger.info(str(resp))
error = resp.get('strError', None)
if error:
if '(28)' in error:
time.sleep(3)
continue
elif '(25)' in error:
return '25'
break
sellm_thread = active_accs[login].get('sellm_thread')
if not sellm_thread:
sellm_thread = threading.Thread(target=sell_market,
args=(steam_client, volume))
active_accs[login]['sellm_thread'] = True
sellm_thread.start()
buygifts_thread = active_accs[login].get('buygifts_thread')
if not buygifts_thread:
buygifts_thread = threading.Thread(target=buy_gifts,
args=(steam_client, volume))
active_accs[login]['buygifts_thread'] = True
buygifts_thread.start()
return 'OK'
class TradeBoost:
GAME = GameOptions.STEAM
def __init__(self, cfg_account: str, recipient_id: str) -> None:
self.cfg_account = json.load(open(cfg_account))
self.login = self.cfg_account["login"]
self.api_token = self.cfg_account['API']
self.password = self.cfg_account['password']
self.recipient_id = recipient_id
self.partner_id = int(self.recipient_id) - 76561197960265728
self.adapter = CustomAdapter(logger, {'account': self.login})
try:
self.account = SteamClient(self.api_token)
self.account.login(self.login, self.password, cfg_account)
self.adapter.info(translate.word('good_auth'))
self.decline_all_trades()
except steampy.exceptions.InvalidCredentials as e:
self.adapter.warning(translate.word('bad_auth').format(e))
def decline_all_trades(self):
params = {
'key': self.api_token,
'get_sent_offers': 1,
'get_received_offers': 0,
'get_descriptions': 0,
'language': 'english',
'active_only': 1,
'historical_only': 0,
'time_historical_cutoff': ''
}
response = (self.account.api_call('GET', 'IEconService',
'GetTradeOffers', 'v1',
params).json()['response'])
count_decline = 0
if 'trade_offers_sent' in response:
for offer in response['trade_offers_sent'][:5]:
if offer['accountid_other'] == self.partner_id:
self.account.cancel_trade_offer(offer['tradeofferid'])
count_decline += 1
self.adapter.info(
translate.word('trade_decline').format(count_decline))
def get_item(self) -> str:
try:
items = self.account.get_my_inventory(game=self.GAME, count=15)
item_id = choice(list(items.keys()))
about_item = items[item_id]
if item_id and state.not_in(
item_id) and about_item['tradable'] == 1:
self.adapter.info(
translate.word('item_received').format(
item_id, about_item["name"]))
state.add(item_id)
return item_id
else:
return ''
except Exception as e:
self.adapter.warning(translate.word('bad_send').format(e))
return ''
def send_trades(self) -> str:
item_id = ''
while item_id in ['', None]:
item_id = self.get_item()
asset_one = Asset(item_id, self.GAME)
trade = self.account.make_offer([asset_one], [], self.recipient_id)
if validate_api_response(trade):
self.adapter.info(
translate.word('sent_trade').format(trade["tradeofferid"]))
return trade['tradeofferid']
else:
self.adapter.warning(
translate.word('bad_send').format(list(trade.values())[0]))
self.decline_all_trades()
def accept_trade(self, trade_id: str) -> None:
trade_info = self.account.get_trade_offer(trade_id)
if 'offer' in trade_info['response']:
if int(trade_info['response']['offer']
['accountid_other']) == self.partner_id:
resp = self.account.accept_trade_offer(trade_id)
if validate_api_response(resp):
self.adapter.info(
translate.word('accepted_trade').format(trade_id))
item = trade_info['response']['offer']['items_to_receive'][
0]['assetid']
state.remove(item)
else:
self.adapter.warning(
translate.word('bad_accept').format(
trade_id,
list(resp.values())[0]))
else:
self.adapter.warning(translate.word('bad_send').format(trade_info))
for id_, skin_descr in my_skins.items():
if not skin_descr['tradable'] or skin_descr['classid'] in box_classids:
continue
skin_name = skin_descr['market_hash_name']
lowest_price = lowest_prices[skin_name]['price']
if lowest_price != 2: # lowest price on opskins is 2 cents
lowest_price -= 1
# average_price = prices_db[skin_name][0]
# if lowest_price / average_price < 0.99:
# lowest_prices = average_price * 0.99
# logger.info('lowest price is 1 perc. and more less than purchase one: %s', skin_name)
item = {
'appid': 730,
'assetid': id_,
'contextid': 2,
'price': lowest_price
}
items.append(item)
prices_db.close()
end = ops.get_listing_limit()
start = 0
while True:
items_slice = items[start:end]
resp = ops.list_items(items)
if resp['tradeoffer_error']:
time.sleep(10)
continue
steam_client.accept_trade_offer(resp['tradeoffer_id'],
resp['bot_id64'])
start, end = end, end + 50
