web3-wizzard-lib 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

core/modules/debank_checker.py

@@ -1,90 +0,0 @@
-import requests
-from sybil_engine.module.module import Module
-from sybil_engine.utils.accumulator import add_accumulator, get_value
-from sybil_engine.utils.statistic_utils import statistic_date_string, get_statistic_writer
-
-TOTAL_USD = "TotalUSD"
-DEBANK_ACC_NUM = "DEBANK_ACC_NUM"
-
-
-class DebankChecker(Module):
-    module_name = "DEBANK_CHECKER"
-    module_config = None
-
-    cumulative_chain_sums = {}
-
-    supported_chains = [
-        'ethereum',
-        'arbitrum',
-        'op',
-        'zksync era',
-        'base',
-        'bnb Chain',
-        'linea',
-        'polygon',
-        'avalanche',
-        'scroll',
-        'core',
-        'fantom',
-        'zora',
-        'arbitrum nova',
-        'celo',
-        'klaytn'
-    ]
-
-    def execute(self, account, statistic_write='GOOGLE'):
-        data = self.debank_request(account)
-
-        job_name = f"debank_{statistic_date_string}"
-        statistics_writer = get_statistic_writer()
-
-        add_accumulator(DEBANK_ACC_NUM, 1)
-
-        total_usd_value = data.get('total_usd_value', 0)
-        chain_list = data.get('chain_list', [])
-        chain_list = [item for item in chain_list if item['name'].lower() in self.supported_chains]
-        chain_list = sorted(chain_list, key=lambda x: x['community_id'])
-
-        chain_names = [chain.get('name') for chain in chain_list]
-
-        statistics_writer.init_if_required(
-            job_name,
-            ['ADS ID', 'Wallet ID', 'Total USD Value'] + chain_names
-        )
-
-        row = [account.app_id, account.address, total_usd_value]
-        for chain in chain_list:
-            usd_value = chain.get('usd_value', 0)
-            row.append(usd_value)
-
-            if chain['name'] in self.cumulative_chain_sums:
-                self.cumulative_chain_sums[chain['name']] += usd_value
-            else:
-                self.cumulative_chain_sums[chain['name']] = usd_value
-
-        statistics_writer.write_row(job_name, row)
-
-        add_accumulator(TOTAL_USD, total_usd_value)
-
-        if get_value(DEBANK_ACC_NUM) == get_value("Acc Amount"):
-            cumulative_row = ['SUM', '', get_value(TOTAL_USD)]
-            for chain_name in chain_names:
-                cumulative_row.append(self.cumulative_chain_sums.get(chain_name, 0))
-
-            statistics_writer.write_row(job_name, cumulative_row)
-
-    def debank_request(self, account):
-        url = "https://pro-openapi.debank.com/v1/user/total_balance"
-        params = {
-            'id': account.address
-        }
-        headers = {
-            'accept': 'application/json',
-            'AccessKey': '6cd56a970242386fa2a57e380c39f00f10b31778'
-        }
-        response = requests.get(url, headers=headers, params=params)
-        data = response.json()
-        return data
-
-    def log(self):
-        return "Debank Checker"

core/modules/dmail.py

@@ -1,54 +0,0 @@
-import random
-from hashlib import sha256
-
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.module.module import Order, RepeatableModule
-from sybil_engine.utils.utils import interval_to_int
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.dmail_send_mail import DmailSend
-
-
-class Dmail(RepeatableModule):
-    module_name = 'DMAIL'
-    module_config = 'send_dmail_config'
-    allowed_chains = ['ZKSYNC', 'LINEA', 'SCROLL', 'MANTA', 'BASE']
-    random_order = Order.RANDOM
-    repeat_conf = 'email_amount'
-
-    @RepeatableModule.repeatable_log
-    def execute(self, chain, account):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        dmail_contract_address = get_contracts_for_chain(chain)["DMAIL"]
-
-        email = sha256(str(1e11 * random.random()).encode()).hexdigest()
-        theme = sha256(str(1e11 * random.random()).encode()).hexdigest()
-
-        args = [account, email, theme]
-
-        dmail_sender = self.get_contract_class()(dmail_contract_address, web3)
-
-        dmail_sender.send_mail(*args)
-
-    def log(self):
-        return "SEND EMAIL"
-
-    def get_contract_class(self):
-        return DmailSend
-
-    def parse_params(self, module_params):
-        self.validate_supported_chain(module_params['chain'])
-
-        return (module_params['chain'],)
-
-    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]))

core/modules/erc20_balance.py

@@ -1,42 +0,0 @@
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.module.module import Order, Module
-from sybil_engine.utils.accumulator import add_accumulator_balance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.dmail_send_mail import DmailSend
-
-
-class Erc20BalanceModule(Module):
-    module_name = 'ERC20_BALANCE_MODULE'
-    module_config = 'erc20_balance'
-    allowed_chains = ['ZKSYNC', 'LINEA', 'SCROLL', 'MANTA', 'BASE']
-    cumulative_sum = 0
-
-    def execute(self, token_address, chain, account):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        erc20_token = Erc20Token('LINEA', token_address, web3)
-
-        balance = erc20_token.balance(account)
-
-        self.cumulative_sum = self.cumulative_sum + balance.wei
-
-        logger.info(f"{account.address} balance is {balance}")
-        add_accumulator_balance("Total balance is", balance.wei)
-
-    def log(self):
-        return "ERC20 BALANCE"
-
-    def get_contract_class(self):
-        return DmailSend
-
-    def parse_params(self, module_params):
-        self.validate_supported_chain(module_params['chain'])
-
-        return module_params['token_address'], module_params['chain']
-
-    def order(self):
-        return Order.RANDOM

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)

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

core/modules/intract_claim.py

@@ -1,104 +0,0 @@
-from json import load
-
-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.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 import TgReport, WindowName, make_text_border
-
-with open('resources/verify_data.json') as f:
-    VERIFY_DATA = load(f)
-
-
-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']
-        ]

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]))