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

web3_wizzard_lib/core/modules/gmx_reward.py

@@ -0,0 +1,25 @@
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.module.module import Module
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.gmx_reward_router import GmxRewardRouter
+
+
+class GMXRewardRouter(Module):
+    module_name = 'GMX_REWARD_ROUTER'
+    module_config = None
+
+    def execute(self, account, chain='ARBITRUM'):
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, None)
+
+        contract_address = get_contracts_for_chain(chain_instance['chain'])['GMX_REWARD_ROUTER']
+        gmx_reward_router = GmxRewardRouter(contract_address, web3)
+
+        token = Erc20Token(chain, '0x1aDDD80E6039594eE970E5872D247bf0414C8903', web3)
+        gmx_reward_router.unstake_and_redeem(account, token.balance(account).wei)
+
+    def log(self):
+        return "GMX REWARD WITHDRAW"

web3_wizzard_lib/core/modules/intract/intract_api.py

@@ -0,0 +1,212 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,134 @@
+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)