web3-wizzard-lib 1.6.10__py3-none-any.whl → 1.6.12__py3-none-any.whl

web3_wizzard_lib/core/modules/intract/intract_api.py

@@ -1,212 +0,0 @@
-from loguru import logger
-#from pyuseragents import random as random_ua
-from requests import Session
-from sybil_engine.utils.retry import retry
-
-
-class IntractAPI:
-    def __init__(self, account):
-        self.account = account
-        self.session = Session()
-        self.session.headers['user-agent'] = random_ua()
-        if account.proxy is not None and account.proxy != '':
-            self.session.proxies.update({'http': account.proxy, 'https': account.proxy})
-        else:
-            logger.warning('You are not using proxy')
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def intract_get_nonce(self, address: str):
-        payload = {'walletAddress': address}
-        url = 'https://api.intract.io/api/qv1/auth/generate-nonce'
-
-        self.session.headers.clear()
-        r = self.session.post(url, json=payload)
-
-        if r.json().get('success') == True:
-            return r.json()['data']['nonce']
-        else:
-            logger.debug(f'nonce intract response: {r.status_code} {r.reason} | {r.text}')
-            raise Exception(f'Couldnt generate nonce for Intract')
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def intract_login(self, address: str, signature: str):
-        payload = {
-            "signature": signature,
-            "userAddress": address,
-            "chain": {"id": 59144, "name": "Linea", "network": "Linea",
-                      "nativeCurrency": {"decimals": 18, "name": "Ether", "symbol": "ETH"},
-                      "rpcUrls": {"public": {"http": ["https://linea.drpc.org"]}, "default": {
-                          "http": ["https://linea-mainnet.infura.io/v3/bfc263a4f3cf49998641d16c24fd0b46"]}},
-                      "blockExplorers": {"etherscan": {"name": "Lineascan", "url": "https://lineascan.build/"},
-                                         "default": {"name": "Lineascan", "url": "https://lineascan.build/"}},
-                      "unsupported": False},
-            "isTaskLogin": False,
-            "width": "590px",
-            "reAuth": False,
-            "connector": "metamask",
-            "referralCode": None,
-            "referralLink": None,
-            "referralSource": None
-        }
-        url = 'https://api.intract.io/api/qv1/auth/wallet'
-
-        r = self.session.post(url, json=payload)
-
-        if r.json().get('isEVMLoggedIn') == True:
-            self.user_id = self.get_user()['_id']
-
-            self.session.headers.update({
-                'Cookies': r.headers["Set-Cookie"].split(';')[0],
-                'Questuserid': self.user_id,
-            })
-            return True
-        else:
-            logger.debug(f'login intract response: {r.status_code} {r.reason} | {r.text}')
-            raise Exception(f'Couldnt login Intract')
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def intract_get_tasks(self, compaignID):
-        self.active_tasks = []
-
-        url = f'https://api.intract.io/api/qv1/campaign/{compaignID}'
-        r = self.session.get(url)
-
-        wave = r.json()
-        # for wave in r.json():
-        if wave["status"] == 'ACTIVE' and wave.get('locked') != True: self.active_tasks.append(wave["name"])
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def set_wallet(self, address: str):
-        try:
-            if self.get_user().get('lineaWalletAddress'):
-                return True
-
-            payload = {
-                "userId": self.user_id,
-                "lineaWalletAddress": address
-            }
-            url = 'https://api.intract.io/api/qv1/linea/user/set-wallet'
-            r = self.session.post(url, json=payload)
-
-            if r.json().get('message') == "Linea wallet address updated successfully":
-                logger.info(f'Wallet successfully linked')
-                return True
-        except Exception as err:
-            raise Exception(f'Couldnt set wallet: {err} | {r.text}')
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def intract_streak(self):
-        try:
-            url = 'https://api.intract.io/api/qv1/linea/user/streak'
-            r = self.session.post(url, json={})
-
-            streakCount = r.json().get('streakCount')
-            isFirstTimeMarked = r.json().get('isFirstTimeMarked')
-
-            if streakCount:
-                logger.info(f'New GM streak: {streakCount + 1}')
-            elif isFirstTimeMarked:
-                logger.info(f'New GM streak: 1')
-            elif 'Linea streak already done for today' in r.text:
-                logger.info(f'New GM streak: already did streak today')
-            else:
-                raise Exception(f'bad response {r.status_code} {r.reason}')
-        except Exception as err:
-            if 'Internal server error' in r.text:
-                logger.error(f'Couldnt use GM streak')
-            else:
-                logger.error(f'Couldnt post streak: {err} | {r.text}')
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def get_user(self):
-        try:
-            url = 'https://api.intract.io/api/qv1/auth/get-user?projectId=660c1fa77851c55d93a1c0e0'
-            r = self.session.get(url)
-            return r.json()
-
-        except Exception as err:
-            raise Exception(f'Couldnt get user: {err} | {r.text}')
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def get_super_user(self):
-        try:
-            # self.intract_streak()
-
-            url = 'https://api.intract.io/api/qv1/auth/get-super-user'
-            r = self.session.get(url)
-
-            return {
-                'achieves': len(r.json().get('badges')),
-                'streak': r.json().get('gmStreak')['streakCount'],
-                'gems': r.json().get('totalGems'),
-                'xp': r.json().get('totalXp'),
-                'super_user_id': r.json().get('_id'),
-            }
-
-        except Exception as err:
-            raise Exception(f'Couldnt get super user: {err} | {r.text}')
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def claim_achievements(self):
-        try:
-            url = 'https://api.intract.io/api/qv1/achievement/init'
-            r = self.session.post(url)
-
-            for achieve in r.json():
-                if achieve["isClaimed"] == False and achieve["isCompleted"] == True:
-                    try:
-                        payload = {
-                            "achievementIds": [achieve["achievementId"]]
-                        }
-                        url = 'https://api.intract.io/api/qv1/achievement/claim'
-                        r = self.session.post(url, json=payload)
-
-                        if 'User achievement reward already claimed' in r.text or 'User achievement not found' in r.text:
-                            pass
-                        else:
-                            logger.info(f'Claimed achievement: {r.json()[0]["name"]}')
-                    except Exception as err:
-                        logger.error(
-                            f'Claim achievement {achieve["achievementId"]} {achieve["name"]} error: {err} | {r.text}')
-
-        except Exception as err:
-            logger.error(f'Couldnt fetch achievements: {err} | {r.text}')
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def activate_journey(self, campaign_id: str):
-        url = f'https://api.intract.io/api/qv1/journey/fetch?campaignId={campaign_id}&channelCode=DEFAULT&referralCode=null'
-
-        r = self.session.get(url)
-        if r.json().get('isActive') != True:
-            logger.error(f'Activate journey error: {r.text}')
-
-        return r.json()
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def verify_quest(self, task):
-        data = {
-            "campaignId": task['campaignId'],
-            "userInputs": {},
-            "userVerificationData": {},
-            "taskId": task['_id']
-        }
-
-        headers = {
-            'questuserid': self.session.headers['Questuserid'],
-            'authorization': f'Bearer {self.session.headers["Cookies"].split('=')[1]}'
-        }
-
-        url = 'https://api.intract.io/api/qv1/task/verify-v2'
-        r = self.session.post(url, json=data, headers=headers)
-
-        logger.info(r.json())
-
-        if r.json()['verified'] == 'False':
-            raise Exception("Quest wasn't verified")
-
-        return r.status_code
-
-    def set_primary_task_identity(self, account):
-        url = 'https://api.intract.io/api/qv1/auth/set-primary-task-identity'
-        payload = {"identity": account.address, "namespaceTag": "EVM"}
-        r = self.session.post(url, json=payload)

web3_wizzard_lib/core/modules/intract/utils.py

@@ -1,81 +0,0 @@
-from inspect import getsourcefile
-from random import randint
-from requests import post
-from loguru import logger
-from time import sleep
-from tqdm import tqdm
-import sys
-import ctypes
-import os
-sys.__stdout__ = sys.stdout
-
-TG_BOT_TOKEN = '' # токен от тг бота (`12345:Abcde`) для уведомлений. если не нужно - оставляй пустым
-TG_USER_ID = [] # тг айди куда должны приходить уведомления. [21957123] - для отправления уведомления только себе, [21957123, 103514123] - отправлять нескольким людями
-
-windll = ctypes.windll if os.name == 'nt' else None # for Mac users
-
-
-class WindowName:
-    def __init__(self):
-        try: self.path = os.path.abspath(getsourcefile(lambda: 0)).split("\\")[-2]
-        except: self.path = os.path.abspath(getsourcefile(lambda: 0)).split("/")[-2]
-
-        self.accs_done = 0
-        self.modules_amount = 0
-        self.modules_done = 0
-
-    def update_accs(self):
-        self.accs_done += 1
-        self.modules_amount = 0
-        self.modules_done = 0
-
-    def update_modules(self):
-        self.modules_done += 1
-
-    def set_modules(self, modules_amount: int):
-        self.modules_amount = modules_amount
-
-
-class TgReport:
-    def __init__(self):
-        self.logs = ''
-
-
-    def update_logs(self, text: str):
-        self.logs += f'{text}\n'
-
-
-    def send_log(self, wallet, window_name, mode: str):
-        notification_text = f'[{window_name.accs_done}/{window_name.accs_amount}] <i>{wallet.address}</i>\n\n' \
-                            f'{self.logs}\n'
-        if mode == 'Claim quests': notification_text += f'{wallet.stats.get("status")}'
-
-        texts = []
-        while len(notification_text) > 0:
-            texts.append(notification_text[:1900])
-            notification_text = notification_text[1900:]
-
-        if TG_BOT_TOKEN:
-            for tg_id in TG_USER_ID:
-                for text in texts:
-                    try: post(f'https://api.telegram.org/bot{TG_BOT_TOKEN}/sendMessage?parse_mode=html&chat_id={tg_id}&text={text}')
-                    except Exception as err: logger.error(f'[-] TG | Send Telegram message error to {tg_id}: {err}')
-
-
-def sleeping(*timing):
-    if type(timing[0]) == list: timing = timing[0]
-    if len(timing) == 2: x = randint(timing[0], timing[1])
-    else: x = timing[0]
-    for _ in tqdm(range(x), desc='sleep ', bar_format='{desc}: {n_fmt}/{total_fmt}'):
-        sleep(1)
-
-
-def make_text_border(text: str):
-    new_text = ''
-    max_len = max([len(string) for string in text.split('\n')])
-
-    new_text += '+' + '-' * (max_len + 8) + '+\n'
-    for string in text.split('\n'): new_text += f'\t{string}\n'
-    new_text += '+' + '-' * (max_len + 8) + '+\n'
-
-    return new_text

web3_wizzard_lib/core/modules/intract_claim.py

@@ -1,101 +0,0 @@
-from eth_account.messages import encode_defunct
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.module.module import Module
-from sybil_engine.utils.file_loader import load_abi
-from sybil_engine.utils.utils import AccountException
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.modules.intract.intract_api import IntractAPI
-from web3_wizzard_lib.core.modules.intract.utils import TgReport, WindowName, make_text_border
-
-VERIFY_DATA = load_abi("resources/verify_data.json")
-
-class IntractClaim(Module):
-    module_name = 'INTRACT_CLAIM'
-    module_config = None
-
-    def execute(self, task_id, account, compaign_id='66bb5618c8ff56cba848ea8f', from_chain='LINEA'):
-        windowname = WindowName()
-
-        intract_api = IntractAPI(account)
-        tg_report = TgReport()
-        windowname.update_accs()
-
-        stats = {}
-
-        web3 = init_web3(get_chain_instance(from_chain), None)
-
-        self.authorize(intract_api, compaign_id, account, web3)
-
-        campaign_funcs = {
-            "Linea LXP Latest Rush": self.linea_lxp,
-        }
-        intract_api.set_primary_task_identity(account)
-        intract_api.activate_journey(compaign_id)
-        linea_xp = intract_api.get_user().get("totalXp") or "0"
-
-        if task_id == 'SKIP_CHECK':
-            if int(linea_xp) == 100:
-                raise AccountException("Skip account tasks where already claimed")
-            else:
-                return
-
-        for task in intract_api.active_tasks:
-            if task in list(campaign_funcs.keys()):
-                campaign_funcs[task](task, task_id, intract_api)
-            else:
-                logger.info(f' > Task "{task}" will appear soon...')
-
-        account_data = intract_api.get_super_user()
-        linea_xp = intract_api.get_user().get("totalXp") or "0"
-
-        logger.info('')  # for clearly logs
-        tg_report.update_logs('<i>Statistics</i>')
-        logger.info('')
-        text = f'Achievements: {account_data["achieves"]}\n' \
-               f'GM Streak: {account_data["streak"]}\n' \
-               f'Gems: {account_data["gems"]}\n' \
-               f'XP: {account_data["xp"]}\n' \
-               f'Linea XP: {linea_xp}'
-        new_text = make_text_border(text=text)
-        for string in new_text.split('\n'): logger.success(string)
-
-        stats.update({
-            'linea_xp': linea_xp,
-            'xp': account_data["xp"],
-            'gm_streak': account_data["streak"],
-            'achievements': account_data["achieves"],
-            'gems': account_data["gems"],
-        })
-
-    def authorize(self, browser, compaign_id, account, web3):
-        nonce = browser.intract_get_nonce(address=account.address)
-        text = f'Nonce: {nonce}'
-        signature = f'0x{web3.eth.account.sign_message(encode_defunct(text=text), private_key=account.key).signature.hex()}'
-        browser.intract_login(address=account.address, signature=signature)
-        browser.intract_get_tasks(compaign_id)
-
-        browser.set_wallet(address=account.address)
-        #browser.claim_achievements()
-
-    def linea_lxp(self, task_name: str, task_id, intract_api, week=0):
-        logger.info(f' > Completing "{task_name}"...')
-
-        for task in VERIFY_DATA['campaigns'][str(week)]['quest']['tasks']:
-            if task_id is not None:
-                if task['_id'] == task_id:
-                    intract_api.verify_quest(task)
-            else:
-                intract_api.verify_quest(task)
-
-    def log(self):
-        return "INTRACT CLAIM"
-
-    def parse_params(self, module_params):
-        if 'taskID' not in module_params:
-            module_params['taskID'] = None
-
-        return [
-            module_params['taskID']
-        ]

web3_wizzard_lib/core/modules/layer_2_20.py

@@ -1,65 +0,0 @@
-import random
-
-from loguru import logger
-from sybil_engine.contract.send import Send
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance import NativeBalance
-from sybil_engine.domain.balance.balance_utils import get_native_balance
-from sybil_engine.module.module import Order, RepeatableModule
-from sybil_engine.utils.utils import interval_to_int, ConfigurationException
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.modules.bridge.orbiter_sub import bridge_codes
-
-
-class Layer2_20(RepeatableModule):
-    module_name = 'Layer2_20'
-    allowed_chains = ['ZKSYNC', 'OPTIMISM', 'BASE', 'LINEA', 'ARBITRUM', 'SCROLL']
-    random_order = Order.RANDOM
-    repeat_conf = 'repeats'
-    module_config = 'layer_2_20_config'
-
-    @RepeatableModule.repeatable_log
-    def execute(self, chains, to_chains, account):
-        chain = random.choice(chains)
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        temp_to_chains = [item for item in to_chains if item != chain]
-        if not temp_to_chains:
-            raise ConfigurationException("No chains to send to")
-        to_chain = random.choice(temp_to_chains)
-
-        layer2_20_contract_address = get_contracts_for_chain(chain)["LAYER2_20"]
-
-        send = Send(layer2_20_contract_address, web3)
-
-        amount_to_send = NativeBalance(
-            230000000000000 + bridge_codes[to_chain],
-            chain,
-            chain_instance['gas_token']
-        )
-        data = '0x646174613a2c7b2270223a226c61796572322d3230222c226f70223a22636c61696d222c227469636b223a22244c32222c22616d74223a2231303030227d'
-
-        native_balance = get_native_balance(account, web3, chain_instance)
-
-        logger.info(f"Native {chain} balance: " + str(native_balance))
-        logger.info(f"Inscription {chain} -> {to_chain} | {amount_to_send}")
-
-        send.send_to_wallet(account, layer2_20_contract_address, amount_to_send, data)
-
-    def log(self):
-        return "LAYER2_20"
-
-    def parse_params(self, module_params):
-        return module_params['chains'], module_params['to_chains']
-
-    def order(self):
-        return Order.RANDOM
-
-    def repeats(self, module_params):
-        if self.repeat_conf not in module_params:
-            return 1
-        else:
-            return range(interval_to_int(module_params[self.repeat_conf]))

web3_wizzard_lib/core/modules/lending_module.py

@@ -1,134 +0,0 @@
-import random
-
-from loguru import logger
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance import NativeBalance
-from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance, from_eth_to_wei, verify_balance
-from sybil_engine.module.module import Order, RepeatableModule
-from sybil_engine.utils.app_account_utils import AppAccount
-from sybil_engine.utils.utils import ConfigurationException, interval_to_round
-from sybil_engine.utils.validation_utils import validate_amount_interval, validate_interval
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.basiliskcontract import BasiliskContract
-from web3_wizzard_lib.core.contract.eralendcontract import EraLendContract
-from web3_wizzard_lib.core.contract.reactor_fusion_contract import ReactorFusionContract
-from web3_wizzard_lib.core.modules.bank.layerbank import LayerBank
-from web3_wizzard_lib.core.modules.bank.aave import Aave
-
-
-class Lending(RepeatableModule):
-    module_name = 'LENDING'
-    module_config = 'lending_config'
-    random_order = Order.RANDOM
-
-    @RepeatableModule.repeatable_log
-    def execute(self, lending_apps, amount: float, action: str, withdraw_sleep_interval: dict, chain,
-                account: AppAccount):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        lending_app_name = random.choice(lending_apps)
-        lending_app = self.get_lending_app(lending_app_name, chain, web3)
-
-        verify_balance(self.min_native_balance, chain_instance, account, web3)
-
-        if action == 'DEPOSIT':
-            self.deposit(account, amount, lending_app, lending_app_name, chain, web3)
-        elif action == 'WITHDRAW':
-            self.withdraw(account, amount, chain, lending_app, lending_app_name)
-        elif action == 'WITHDRAW_ALL':
-            for app_name, app in self.lending_apps_with_deposit(account, chain, web3):
-                self.withdraw(account, amount, chain, app, app_name)
-        else:
-            raise ConfigurationException("Unsupported action")
-
-    def deposit(self, account, amount, lending_app, lending_app_name, chain, web3):
-        amount_balance = interval_to_eth_balance(amount, account, chain, web3)
-
-        if amount == 'all_balance':
-            amount_balance = amount_balance.minus(self.min_native_balance)
-
-        logger.info(f"Make deposit on {lending_app_name} | {amount_balance}")
-
-        lending_app.mint(account, amount_balance.wei)
-
-    def withdraw(self, account, amount, chain, lending_app, lending_app_name):
-        deposit_balance = NativeBalance(lending_app.get_deposit_amount(account), chain, 'ETH')
-
-        if deposit_balance.wei < 1000000000000:
-            raise EmptyDepositException(f"[{account.address}] Deposit balance is 0, skip")
-
-        logger.info(f"Deposit balance: {deposit_balance}")
-
-        if amount == 'all_balance':
-            withdraw_wei = deposit_balance.wei
-        else:
-            balance = NativeBalance(from_eth_to_wei(interval_to_round(amount)), chain, 'ETH')
-            amount_balance = NativeBalance(int(balance.wei // 10000) * 10000, chain, balance.token)
-            withdraw_wei = amount_balance.wei
-
-            if deposit_balance.wei < withdraw_wei:
-                logger.info(
-                    f"Deposit {deposit_balance} < withdraw amount {amount_balance}"
-                    f", withdrawing all deposit")
-                withdraw_wei = deposit_balance.wei
-
-        logger.info(f"Withdraw from {lending_app_name} | {deposit_balance}")
-
-        lending_app.redeem_underlying(account, withdraw_wei)
-
-    def get_lending_app(self, lending_app, chain, web3):
-        lending_apps = self.get_lending_apps(chain, web3)
-
-        if lending_app not in lending_apps.keys():
-            raise ConfigurationException(f"{lending_app} not supported in {chain}. Supported lending: {list(lending_apps.keys())} supported")
-
-        return lending_apps[lending_app]
-
-    def get_lending_apps(self, chain, web3):
-        contracts = get_contracts_for_chain(chain)
-
-        apps = {
-            'BASILISK_LANDING': BasiliskContract,
-            'REACTORFUSION_LANDING': ReactorFusionContract,
-            'ERALEND': EraLendContract,
-            'AAVE': Aave,
-            'LAYERBANK': LayerBank
-        }
-
-        return {k: v(contracts[k], web3) for k, v in apps.items() if k in contracts}
-
-    def lending_apps_with_deposit(self, account, chain, web3):
-        with_deposit = []
-
-        for lending_app_name, lending_app in self.get_lending_apps(chain, web3).items():
-            if lending_app.get_deposit_amount(account) > 1000000000000:
-                with_deposit.append((lending_app_name, lending_app))
-
-        return with_deposit
-
-    def log(self):
-        return "LENDING"
-
-    def parse_params(self, module_params):
-        validate_amount_interval(module_params['amount'])
-        validate_interval(module_params['withdraw_sleep_interval'])
-
-        if 'chain' not in module_params:
-            module_params['chain'] = 'ZKSYNC'
-
-        return [
-            module_params['lending_apps'],
-            module_params['amount'],
-            module_params['action'],
-            module_params['withdraw_sleep_interval'],
-            module_params['chain']
-        ]
-
-
-class EmptyDepositException(Exception):
-    def __init__(self, message):
-        self.message = message
-        super().__init__(self.message)