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

web3_wizzard_lib/core/modules/claims/layerzero_claimer.py

@@ -1,64 +0,0 @@
-import requests
-from loguru import logger
-from sybil_engine.config.app_config import get_cex_conf, get_cex_data
-from sybil_engine.domain.balance.balance import NativeBalance, Erc20Balance
-from sybil_engine.domain.balance.balance_utils import get_native_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.domain.cex.okx import OKX
-
-total_zro = 0
-
-def claimer_zro(account, chain_instance, token, web3):
-    allocation_data = get_allocation(account.address)
-    if not allocation_data:
-        raise Exception("Failed to fetch allocation data.")
-    amount_raw = int(allocation_data.get('zroAllocation', {}).get('asBigInt'))
-    logger.info(f"ZRO Allocation for {account.address} is {amount_raw}")
-    if token == 'NATIVE':
-        withdraw_token = chain_instance['gas_token']
-        claim_price = NativeBalance(int((round(amount_raw / 10 ** 18) + 1) * 0.00005 * 10 ** 18),
-                                    chain_instance['chain'], token)
-        balance = get_native_balance(account, web3, chain_instance)
-        logger.info(f"Native balance is {balance}")
-    else:
-        claim_price = Erc20Balance(
-            int((round(amount_raw / 10 ** 18) + 1) * 0.00003 * 10 ** 18),
-            chain_instance['chain'],
-            token,
-            decimal=18
-        )
-        withdraw_token = token
-        balance = Erc20Token(chain_instance['chain'], token, web3).balance(account)
-        logger.info(f"Native balance is {balance}")
-    logger.info(f"Need {claim_price} for claim")
-    if claim_price.wei > balance.wei:
-        password, cex_data = get_cex_data()
-        cex_obj = OKX(cex_data[get_cex_conf()], password)
-        cex_obj.withdrawal(account.address, chain_instance['chain'], float(balance.readable()), withdraw_token)
-
-    proof = get_proof(account.address)
-    logger.info(proof)
-    global total_zro
-    total_zro = total_zro + int(proof['amount'])
-    amount_to_claim = int(proof['amount'])
-    merkle_proof = proof['proof'].split('|')
-    #contract_address = get_contracts_for_chain(chain_instance['chain'])['ZRO_CLAIMER']
-    #claimer = L0Claim(contract_address, web3)
-    #claimer.donateAndClaim(account, claim_price.wei, amount_to_claim, merkle_proof)
-
-def get_proof(wallet):
-    url = f"https://www.layerzero.foundation/api/proof/{wallet}?address={wallet}"
-    response = requests.get(url)
-    if response.status_code == 200:
-        return response.json()
-    else:
-        return None
-
-
-def get_allocation(wallet):
-    url = f"https://www.layerzero.foundation/api/allocation/{wallet}"
-    response = requests.get(url)
-    if response.status_code == 200:
-        return response.json()
-    else:
-        return None

web3_wizzard_lib/core/modules/claims/rabby_claimer.py

@@ -1,81 +0,0 @@
-import time
-from random import randint
-
-from eth_account.messages import encode_defunct, SignableMessage
-from fake_useragent import UserAgent
-from loguru import logger
-
-import requests
-from sybil_engine.utils.utils import randomized_sleeping
-
-url = "https://api.rabby.io/v2/points/claim_snapshot"
-
-headers = {
-    "Host": "api.rabby.io",
-    "Connection": "keep-alive",
-    "Content-Length": "224",
-    "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
-    "X-Version": "0.92.48",
-    "sec-ch-ua-mobile": "?0",
-    "User-Agent": UserAgent().random,
-    "x-api-ts": str(int(time.time())),
-    "Content-Type": "application/json",
-    "x-api-ver": "v2",
-    "Accept": "application/json, text/plain, */*",
-    "X-Client": "Rabby",
-    "sec-ch-ua-platform": '"Windows"',
-    "Origin": "chrome-extension://acmacodkjb dgmoleebolmdjonilkdbch",
-    "Sec-Fetch-Site": "none",
-    "Sec-Fetch-Mode": "cors",
-    "Sec-Fetch-Dest": "empty",
-    "Accept-Encoding": "gzip, deflate, br",
-    "Accept-Language": "uk-UA,uk;q=0.9,en-US;q=0.8,en;q=0.7",
-}
-
-
-def claimer_rabby(account, web3):
-    try:
-        address = account.address.lower()
-        msg = f"{address} Claims Rabby Points"
-
-        payload = {
-            "id": address,
-            "signature": get_signed_code(web3, account, msg),
-            "invite_code": "FREEBONUS"
-        }
-
-        proxies = {}
-        proxies.update(
-            {"http": account.proxy,
-            "https": account.proxy}
-        )
-
-        response = make_request_with_retries(url, headers=headers, json=payload, proxies=proxies)
-
-        if response.json().get("error_code") == 0:
-            logger.success(f"{address} | Claimed!")
-        else:
-            resp_msg = response.json().get("error_msg")
-            logger.info(f"{address} | {resp_msg} | {response.json()}")
-    except Exception as e:
-        logger.error(f"{account}... | {e}")
-
-
-def sign(web3, account, encoded_msg: SignableMessage):
-    return web3.eth.account.sign_message(encoded_msg, account.key)
-
-
-def get_signed_code(web3, account, msg) -> str:
-    return sign(web3, account, encode_defunct(text=msg)).signature.hex()
-
-def make_request_with_retries(url, headers, json, proxies, max_retries=5):
-    for attempt in range(max_retries):
-        response = requests.post(url, headers=headers, json=json, proxies=proxies)
-        if response.status_code == 429:
-            retry_after = int(response.headers.get("Retry-After", randint(1, 5)))
-            logger.info(f"Rate limited. Retrying after {retry_after} seconds. Attempt {attempt + 1}/{max_retries}")
-            time.sleep(retry_after)
-        else:
-            return response
-    logger.error("Max retries reached. Giving up.")
-    return None

web3_wizzard_lib/core/modules/concrete_swap.py

@@ -1,108 +0,0 @@
-import random
-
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance_utils import verify_balance, amount_to_swap_from_interval
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.module.module import Module
-from sybil_engine.utils.utils import SwapException
-from sybil_engine.utils.validation_utils import validate_amount_interval, validate_token
-from sybil_engine.utils.web3_utils import init_web3
-from web3 import Web3
-
-from web3_wizzard_lib.core.modules.swap.swap_list import swap_facade
-
-
-class ConcreteSwap(Module):
-    module_name = 'CONCRETE_SWAP'
-    module_config = 'swap_config'
-    allowed_chains = ['ZKSYNC', 'LINEA', 'BASE', 'SCROLL', 'ARBITRUM']
-    sleep_after_var = True
-
-    def execute(self, chain, amount_interval, from_token, to_token, swap_app, account):
-        if isinstance(swap_app, list):
-            swap_app = random.choice(swap_app)
-
-        self.sleep_after_var = True
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        native_balance = verify_balance(self.min_native_balance, chain_instance, account, web3)
-
-        from_token_contract = Erc20Token(chain, from_token, web3)
-        to_token_contract = Erc20Token(chain, to_token, web3)
-
-        if Web3.is_address(from_token):
-            from_token_symbol = from_token_contract.symbol()
-        else:
-            from_token_symbol = from_token
-
-        if Web3.is_address(to_token):
-            to_token_symbol = to_token_contract.symbol()
-        else:
-            to_token_symbol = to_token
-
-        pair_to_swap = self.create_pair_to_swap(
-            from_token_symbol,
-            swap_app,
-            to_token_symbol,
-        )
-
-        amount_to_swap = amount_to_swap_from_interval(
-            account,
-            chain,
-            self.min_native_balance,
-            native_balance,
-            amount_interval,
-            from_token,
-            web3
-        )
-
-        if amount_to_swap.wei < 100000:
-            logger.info("Low balance, ignore")
-            return
-
-        try:
-            swap_facade.swap(
-                account,
-                amount_to_swap,
-                chain_instance,
-                pair_to_swap,
-                swap_app,
-                from_token,
-                to_token,
-                web3
-            )
-        except SwapException as e:
-            logger.info(e.message)
-            self.sleep_after_var = False
-
-    def create_pair_to_swap(self, from_token, swap_app, to_token):
-        pair_to_swap = {
-            'name': f'{from_token}>{to_token}',
-            'tokens': [from_token, to_token],
-            'slippage': 2,
-            'app': swap_app
-        }
-        return pair_to_swap
-
-    def log(self):
-        return "SWAP"
-
-    def sleep_after(self):
-        return self.sleep_after_var
-
-    def parse_params(self, module_params):
-        self.validate_supported_chain(module_params['chain'])
-        validate_amount_interval(module_params['amount_interval'])
-        validate_token(module_params['from_token'])
-        validate_token(module_params['to_token'])
-        #validate_dex(module_params['app'])
-
-        return (
-            module_params['chain'],
-            module_params['amount_interval'],
-            module_params['from_token'],
-            module_params['to_token'],
-            module_params['app']
-        )

web3_wizzard_lib/core/modules/coredao_bridge.py

@@ -1,32 +0,0 @@
-from sybil_engine.module.module import Order, Module
-
-from web3_wizzard_lib.core.modules.bridge.coredao_bridge_sub import CoreDaoBridgeSubModule
-
-
-class CoreDaoBridge(Module):
-    module_name = 'COREDAO_BRIDGE'
-    allowed_chains = ['POLYGON', 'COREDAO']
-    module_config = 'coredao_bridge_config'
-
-    def execute(self, bridge_amount_interval, from_chain, to_chain, token, account):
-        CoreDaoBridgeSubModule().execute(
-            bridge_amount_interval,
-            from_chain,
-            to_chain,
-            token,
-            self.min_native_balance,
-            account
-        )
-
-    def log(self):
-        return "COREDAO BRIDGE"
-
-    def parse_params(self, module_params):
-        self.validate_supported_chain(module_params['from_chain'])
-        self.validate_supported_chain(module_params['to_chain'])
-
-        return module_params['bridge_amount_interval'], module_params['from_chain'], module_params['to_chain'], \
-            module_params['token']
-
-    def order(self):
-        return Order.RANDOM

web3_wizzard_lib/core/modules/coredao_bridge_auto.py

@@ -1,39 +0,0 @@
-from sybil_engine.module.module import Order, RepeatableModule
-from sybil_engine.utils.utils import interval_to_int, randomized_sleeping
-
-from web3_wizzard_lib.core.modules.bridge.coredao_bridge_sub import CoreDaoBridgeSubModule
-
-
-class CoreDaoBridgeAuto(RepeatableModule):
-    module_name = 'COREDAO_BRIDGE_AUTO'
-    allowed_chains = ['POLYGON', 'COREDAO']
-    random_order = Order.RANDOM
-    repeat_conf = 'repeats'
-    module_config = 'coredao_bridge_auto_config'
-
-    @RepeatableModule.repeatable_log
-    def execute(self, from_chain, to_chain, bridge_amount_interval, token, sleep_interval, account):
-        CoreDaoBridgeSubModule().execute(bridge_amount_interval, from_chain, to_chain, token, account)
-        randomized_sleeping(sleep_interval)
-        CoreDaoBridgeSubModule().execute(bridge_amount_interval, to_chain, from_chain, token, account)
-
-    def log(self):
-        return "COREDAO BRIDGE AUTO"
-
-    def parse_params(self, module_params):
-        return [
-            module_params['from_chain'],
-            module_params['to_chain'],
-            module_params['bridge_amount_interval'],
-            module_params['token'],
-            module_params['sleep_interval'],
-        ]
-
-    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/debank_checker.py

@@ -1,78 +0,0 @@
-from sybil_engine.module.module import Module
-from sybil_engine.utils.accumulator import add_accumulator, get_value
-
-from web3_wizzard_lib.core.utils.statistic_utils import statistic_date_string, get_statistic_writer
-from web3_wizzard_lib.utils.debank_utils import debank_request
-
-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',
-        'utils',
-        'fantom',
-        'zora',
-        'arbitrum nova',
-        'celo',
-        'klaytn'
-    ]
-
-    def execute(self, account, statistic_write='GOOGLE'):
-        data = debank_request(account.address)
-
-        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 log(self):
-        return "Debank Checker"

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

web3_wizzard_lib/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

web3_wizzard_lib/core/modules/gmx_reward.py

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