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

web3_wizzard_lib/core/modules/bridge/orbiter_sub.py

@@ -1,112 +0,0 @@
-import random
-
-from loguru import logger
-from sybil_engine.contract.erc20contract import Erc20Contract
-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.data.tokens import get_tokens_for_chain
-from sybil_engine.domain.balance.balance import NotEnoughNativeBalance
-from sybil_engine.domain.balance.balance_utils import interval_to_erc20_balance, \
-    interval_to_native_balance, verify_balance
-from sybil_engine.utils.utils import ConfigurationException
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.orbiter_starknet import OrbiterStarknet
-from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
-
-bridge_codes = {
-    "ETH": 9001,
-    "ARBITRUM": 9002,
-    "POLYGON": 9006,
-    "OPTIMISM": 9007,
-    "BSC": 9015,
-    "ARBITRUM_NOVA": 9016,
-    "ZKSYNC": 9014,
-    "POLYGON_ZK": 9017,
-    "BASE": 9021,
-    "LINEA": 9023,
-    "SCROLL": 9019,
-    #"X_LAYER": 9027, DONT USE
-    "ZORA": 9030,
-    "MANTA": 9031,
-    "ZKFAIR": 9038
-}
-
-
-class OrbiterSubModule(Bridge):
-    supported_tokens = ['NATIVE', 'USDC', 'USDT', 'WETH']
-
-    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
-        from_chain_instance = get_chain_instance(from_chain)
-        web3 = init_web3(from_chain_instance, account.proxy)
-
-        if isinstance(to_chain, list):
-            to_chain = random.choice(to_chain)
-        if to_chain not in bridge_codes:
-            raise ConfigurationException(f"{to_chain} not supported in orbiter")
-
-        amount = self.__calculate_bridge_amount(account, bridge_amount_interval, from_chain_instance, to_chain, token,
-                                                min_native_balance, web3)
-
-        logger.info(f"Bridge {from_chain} –> {to_chain} | {amount}")
-        self.__perform_bridge(account, amount, from_chain, to_chain, token, web3)
-
-    def __perform_bridge(self, account, amount, from_chain, to_chain, token, web3):
-        if token == 'NATIVE':
-            self.__bridge_native(account, amount, from_chain, to_chain, web3)
-        else:
-            self.__bridge_token(account, amount, from_chain, web3)
-
-    def __calculate_bridge_amount(self, account, bridge_amount_interval, from_chain_instance, to_chain, token,
-                                  min_native_balance, web3):
-        if token == 'NATIVE':
-            native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
-
-            amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
-            if amount.wei > native_without_min.wei:
-                if bridge_amount_interval == 'all_balance':
-                    amount = native_without_min
-                else:
-                    raise NotEnoughNativeBalance(
-                        f"The account balance ({native_without_min}) < bridging amount ({amount}).")
-        else:
-            amount = interval_to_erc20_balance(bridge_amount_interval, account, token, from_chain_instance['chain'],
-                                               web3)
-            if bridge_amount_interval == 'all_balance':
-                amount.wei = amount.wei - 10 ** 5
-
-        amount.wei = self.__adjust_amount_by_bridge_code(amount.wei, to_chain)
-
-        return amount
-
-    def __adjust_amount_by_bridge_code(self, wei_amount, to_chain):
-        bridge_code = bridge_codes.get(to_chain)
-        if not bridge_code:
-            raise ConfigurationException(f"No bridge code found for {to_chain}")
-        return int(f"{wei_amount // 10 ** 4}{bridge_code}")
-
-    def __bridge_native(self, account, amount, from_chain, to_chain, web3):
-        if to_chain == 'STARKNET':
-            if amount.readable() <= 0.0065 or amount.readable() >= 5:
-                raise NotEnoughNativeBalance(f"Limit range amount for starknet 0.0065 – 5 ETH | {amount}")
-
-            if from_chain != 'ZKSYNC':
-                raise ConfigurationException("only ZKSYNC can bridge to STARKNET")
-
-            orbiter_wallet = get_contracts_for_chain(from_chain)['ORBITER_STARKNET']
-            orbiter_starknet = OrbiterStarknet(orbiter_wallet, web3)
-            orbiter_starknet.bridge(account, amount)
-        else:
-            orbiter_wallet = get_contracts_for_chain(from_chain)['ORBITER']
-            send = Send(orbiter_wallet, web3)
-            send.send_to_wallet(account, orbiter_wallet, amount)
-
-    def __bridge_token(self, account, amount, from_chain, web3):
-        contracts = get_contracts_for_chain(from_chain)
-
-        if 'ORBITER_ERC20' not in contracts:
-            raise ConfigurationException(f"ERC20 is not supported for {from_chain}")
-
-        erc20 = Erc20Contract(get_tokens_for_chain(from_chain)[amount.token], web3)
-        erc20.transfer(account, amount, contracts['ORBITER_ERC20'])

web3_wizzard_lib/core/modules/bridge/scroll_bridge_sub.py

@@ -1,42 +0,0 @@
-from sybil_engine.utils.utils import ConfigurationException
-
-from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
-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 NotEnoughNativeBalance
-from sybil_engine.domain.balance.balance_utils import interval_to_native_balance, verify_balance
-
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.eth_scroll_bridge_contract import EthScrollBridgeContract
-from web3_wizzard_lib.core.contract.scroll_bridge_contract import ScrollBridgeContract
-from web3_wizzard_lib.core.contract.scroll_oracle import ScrollOracle
-
-class ScrollBridgeSubModule(Bridge):
-
-    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
-        from_chain_instance = get_chain_instance(from_chain)
-        web3 = init_web3(from_chain_instance, account.proxy)
-        native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
-        amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
-        if amount.wei > native_without_min.wei:
-            if bridge_amount_interval == 'all_balance':
-                amount = native_without_min
-            else:
-                raise NotEnoughNativeBalance(
-                    f"The account balance ({native_without_min}) < bridging amount ({amount}).")
-        if from_chain == 'ETH_MAINNET':
-            contract_oracle = get_contracts_for_chain(from_chain)["SCROLL_ORACLE"]
-            fee = ScrollOracle(contract_oracle, web3).estimateCrossDomainMessageFee()
-
-            scroll_bridge_contract_address = get_contracts_for_chain(from_chain)["SCROLL_BRIDGE"]
-            scroll_bridge = EthScrollBridgeContract(scroll_bridge_contract_address, web3)
-
-            scroll_bridge.sendMessage(account, amount.wei, fee)
-        elif from_chain == 'SCROLL':
-            scroll_bridge_contract_address = get_contracts_for_chain(from_chain)["SCROLL_BRIDGE"]
-            scroll_bridge = ScrollBridgeContract(scroll_bridge_contract_address, web3)
-
-            scroll_bridge.withdraw(account, amount.wei)
-        else:
-            raise ConfigurationException(f"{from_chain} chain is unsupported, only ETH_MAINNET and SCROLL allowed")

web3_wizzard_lib/core/modules/bridge/stargate_v2_sub.py

@@ -1,74 +0,0 @@
-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 NotEnoughNativeBalance
-from sybil_engine.domain.balance.balance_utils import interval_to_native_balance, verify_balance
-from sybil_engine.utils.utils import ConfigurationException
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.stargate_v2_contract import StargateV2Contract
-from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
-
-chain_ids = {
-    'LINEA': 30183,
-    'SCROLL': 30214,
-    'OPTIMISM': 30111,
-    'ARBITRUM': 30110,
-    'BASE': 30184
-}
-
-
-class StargateV2SubModule(Bridge):
-    supported_tokens = ['NATIVE']
-
-    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
-        if token != 'NATIVE':
-            raise ConfigurationException('Currently only native token bridge is supported by Stargate V2')
-
-        from_chain_instance = get_chain_instance(from_chain)
-        web3 = init_web3(from_chain_instance, account.proxy)
-        stargate_v2_contract = get_contracts_for_chain(from_chain)['STARGATE_V2']
-
-        amount = self.__calculate_bridge_amount(
-            account,
-            bridge_amount_interval,
-            from_chain_instance,
-            min_native_balance,
-            web3
-        )
-
-        logger.info(f"Bridge {from_chain} –> {to_chain} | {amount}")
-
-        send_params = (
-            chain_ids[to_chain],
-            f'0x000000000000000000000000{account.address[2:]}',
-            amount.wei,  # amountLD,
-            int(amount.wei * 0.995),  # minAmountLd,
-            b'',
-            b'',
-            b'\x01',
-        )
-
-        stargate_v2 = StargateV2Contract(stargate_v2_contract, web3)
-
-        stargate_fee = stargate_v2.quote_send(send_params)
-
-        stargate_v2.send(
-            account,
-            amount.wei + stargate_fee[0],
-            send_params,
-            stargate_fee,
-            account.address
-        )
-
-    def __calculate_bridge_amount(self, account, bridge_amount_interval, from_chain_instance, min_native_balance, web3):
-        native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
-
-        amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
-        if amount.wei > native_without_min.wei:
-            if bridge_amount_interval == 'all_balance':
-                amount = native_without_min
-            else:
-                raise NotEnoughNativeBalance(
-                    f"The account balance ({native_without_min}) < bridging amount ({amount}).")
-        return amount

web3_wizzard_lib/core/modules/bridge_module.py

@@ -1,47 +0,0 @@
-from sybil_engine.module.module import Module
-from sybil_engine.utils.utils import ConfigurationException
-from sybil_engine.utils.validation_utils import validate_amount_interval, validate_chain
-
-from web3_wizzard_lib.core.modules.bridge.coredao_bridge_sub import CoreDaoBridgeSubModule
-from web3_wizzard_lib.core.modules.bridge.orbiter_sub import OrbiterSubModule
-from web3_wizzard_lib.core.modules.bridge.scroll_bridge_sub import ScrollBridgeSubModule
-from web3_wizzard_lib.core.modules.bridge.stargate_v2_sub import StargateV2SubModule
-
-
-class BridgeModule(Module):
-    module_name = 'BRIDGE'
-    module_config = 'bridge_module'
-
-    supported_tokens = ['NATIVE', 'USDC', 'USDT', 'WETH']
-
-    def execute(self, bridge, bridge_amount_interval, from_chain, to_chain, token, account):
-        if bridge == 'ORBITER':
-            module = OrbiterSubModule()
-        elif bridge == 'STARGATE_V2':
-            module = StargateV2SubModule()
-        elif bridge == 'COREDAO':
-            module = CoreDaoBridgeSubModule()
-        elif bridge == 'SCROLL':
-            module = ScrollBridgeSubModule()
-        else:
-            raise ConfigurationException(f'Bridge {bridge} is not supported')
-
-        module.execute(bridge_amount_interval, from_chain, to_chain, token, self.min_native_balance, account)
-
-    def log(self):
-        return "BRIDGE"
-
-    def parse_params(self, module_params):
-        validate_amount_interval(module_params['bridge_amount_interval'])
-        validate_chain(module_params['from_chain'])
-
-        if 'token' not in module_params:
-            module_params['token'] = 'NATIVE'
-
-        if module_params['token'] not in self.supported_tokens:
-            raise ConfigurationException(
-                f"{module_params['token']} not supported in orbiter. Supported options: {self.supported_tokens}")
-
-        return module_params['bridge'], module_params['bridge_amount_interval'], module_params['from_chain'], \
-            module_params['to_chain'], \
-            module_params['token']

web3_wizzard_lib/core/modules/bungee.py

@@ -1,109 +0,0 @@
-from typing import Union
-
-import requests
-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_utils import get_native_balance, interval_to_eth_balance, from_wei_to_eth
-from sybil_engine.module.module import Module
-from sybil_engine.utils.utils import ConfigurationException
-from sybil_engine.utils.validation_utils import validate_chain, validate_refuel_interval
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.bungee import bungee_chain_ids, Bungee
-
-
-class BungeeRefuel(Module):
-    module_name = 'BUNGEE'
-    module_config = 'bungee_config'
-
-    def execute(self, refuel_amount_interval, from_chain, to_chain, account):
-        from_chain_instance = get_chain_instance(from_chain)
-        web3 = init_web3(from_chain_instance, account.proxy)
-
-        bungee_contract = get_contracts_for_chain(from_chain)['BUNGEE']
-        bungee = Bungee(bungee_contract, web3)
-
-        try:
-            limits = self.get_bungee_limits(from_chain)
-
-            to_chain_limits = [
-                chain for chain in limits if chain["chainId"] == bungee_chain_ids[to_chain] and chain["isEnabled"]
-            ]
-
-            if to_chain_limits:
-                min_amount = float(from_wei_to_eth(int(to_chain_limits[0]["minAmount"])))
-                max_amount = float(from_wei_to_eth(int(to_chain_limits[0]["maxAmount"])))
-
-                if refuel_amount_interval == 'max':
-                    refuel_amount_interval = {'from': max_amount * 0.9, 'to': max_amount * 0.98}
-
-                if refuel_amount_interval == '':
-                    refuel_amount_interval = {'from': min_amount, 'to': max_amount}
-
-                if refuel_amount_interval['from'] < min_amount:
-                    raise ConfigurationException(
-                        f'Min refuel amount for {from_chain} is {min_amount} < {refuel_amount_interval["from"]}')
-
-                if refuel_amount_interval['to'] > max_amount:
-                    raise ConfigurationException(
-                        f'Max refuel amount for {from_chain} is {max_amount} > {refuel_amount_interval["to"]}')
-
-                native_without_min = get_native_balance(account, web3, from_chain_instance).minus(
-                    self.min_native_balance)
-
-                amount = interval_to_eth_balance(refuel_amount_interval, account, from_chain, web3)
-
-                if amount.wei > native_without_min.wei:
-                    amount = native_without_min
-
-                logger.info(f"Refuel {from_chain.title()} > {to_chain.title()} | {amount}")
-
-                bungee.refuel(account, to_chain, amount.wei)
-            else:
-                logger.info("skip")
-        except Exception as e:
-            logger.error(f"Bungee refuel error | error {e}")
-
-    def get_bungee_limits(self, from_chain) -> Union[dict, bool]:
-        bungee_data = self.get_bungee_data()
-
-        try:
-            if from_chain == 'ZKSYNC':
-                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "zkSync"][0]["limits"]
-            elif from_chain == 'ARBITRUM':
-                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Arbitrum"][0]["limits"]
-            elif from_chain == 'OPTIMISM':
-                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Optimism"][0]["limits"]
-            elif from_chain == 'POLYGON':
-                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Polygon"][0]["limits"]
-            elif from_chain == 'AVALANCHE':
-                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Avalanche"][0]["limits"]
-            elif from_chain == 'BSC':
-                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "BSC"][0]["limits"]
-            elif from_chain == 'BASE':
-                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Base"][0]["limits"]
-            else:
-                raise Exception("Not supported")
-
-            return limits
-        except Exception as e:
-            return False
-
-    def get_bungee_data(self):
-        url = "https://refuel.socket.tech/chains"
-        response = requests.get(url)
-        if response.status_code == 200:
-            data = response.json()["result"]
-            return data
-        return False
-
-    def log(self):
-        return "BUNGEE REFUEL"
-
-    def parse_params(self, module_params):
-        validate_chain(module_params['from_chain'])
-        validate_chain(module_params['to_chain'])
-        validate_refuel_interval(module_params['refuel_amount_interval'])
-
-        return module_params['refuel_amount_interval'], module_params['from_chain'], module_params['to_chain']

web3_wizzard_lib/core/modules/cex_sender.py

@@ -1,60 +0,0 @@
-from loguru import logger
-from sybil_engine.contract.send import Send
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance_utils import interval_to_native_balance, interval_to_erc20_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.module.module import Module
-from sybil_engine.utils.accumulator import add_accumulator_native_balance
-from sybil_engine.utils.retry import retry
-from sybil_engine.utils.validation_utils import validate_chain, validate_amount_interval
-from sybil_engine.utils.web3_utils import init_web3
-
-
-class SendToCex(Module):
-    module_name = 'SEND_TO_CEX'
-    module_config = 'send_to_cex_config'
-    supported_chains = ['USDC', 'USDT', 'ZK', 'ZRO', 'OBT']
-
-    def execute(self, chain, send_to_cex_amount_interval, token, account):
-        cex_address = account.cex_address
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        if token == 'NATIVE':
-            amount = interval_to_native_balance(send_to_cex_amount_interval, account, chain_instance['chain'], web3)
-
-            if send_to_cex_amount_interval == 'all_balance':
-                amount = amount.minus(self.min_native_balance)
-        elif token in self.supported_chains:
-            amount = interval_to_erc20_balance(send_to_cex_amount_interval, account, token, chain, web3)
-        else:
-            raise Exception(f"Token {token} not supported. Only NATIVE and USDC/USDT are supported.")
-
-        if amount.wei == 0 :
-            logger.info("Wallet is empty")
-            return
-
-        self.send_funds(account, amount, cex_address, chain, chain_instance, token, web3)
-
-        add_accumulator_native_balance("Total sent to cex", amount.wei)
-
-    @retry(max_attempts=5, retry_interval={'from': 60 * 2, 'to': 60 * 3})
-    def send_funds(self, account, amount, cex_address, chain, chain_instance, token, web3):
-        logger.info(f"Send {amount} to {cex_address} ({chain_instance['chain']})")
-        if token == 'NATIVE':
-            send = Send(None, web3)
-            send.send_to_wallet(account, cex_address, amount)
-        elif token in self.supported_chains:
-            erc20_token = Erc20Token(chain, token, web3)
-            erc20_token.transfer(amount, cex_address, account)
-        else:
-            raise Exception(f"Token {token} not supported. Only NATIVE and USDC/USDT are supported.")
-
-    def log(self):
-        return "SEND TO CEX"
-
-    def parse_params(self, module_params):
-        validate_chain(module_params['chain'])
-        validate_amount_interval(module_params['amount'])
-
-        return module_params['chain'], module_params['amount'], module_params['token']

web3_wizzard_lib/core/modules/cex_subaccount_transfer.py

@@ -1,34 +0,0 @@
-from sybil_engine.config.app_config import get_cex_data, get_cex_conf
-from sybil_engine.domain.cex.binance import Binance
-from sybil_engine.domain.cex.okx import OKX
-from sybil_engine.module.module import Module
-from sybil_engine.utils.app_account_utils import AppAccount
-from sybil_engine.utils.utils import ConfigurationException
-
-
-class CEXSubAccountTransfer(Module):
-    module_name = 'CEX_SUB_ACCOUNT_TRANSFER'
-    module_config = 'cex_account_transfer_config'
-
-    def execute(self, cex, account: AppAccount):
-        password, cex_data = get_cex_data()
-
-        tokens = ['ETH', 'CORE', 'POL', 'USDC', 'USDT', 'OKB', 'ZRO']
-
-        if cex == 'okx':
-            cex_obj = OKX(cex_data[get_cex_conf()], password)
-        elif cex == 'binance':
-            cex_obj = Binance(cex_data[get_cex_conf()], password)
-        else:
-            raise ConfigurationException(f"{cex} is not")
-
-        cex_obj.transfer_from_sub_account(tokens)
-
-    def log(self):
-        return "CEX SUB ACCOUNT TRANSFER"
-
-    def parse_params(self, module_params):
-        if 'cex' not in module_params:
-            module_params['cex'] = 'okx'
-
-        return [module_params['cex']]

web3_wizzard_lib/core/modules/cex_withdraw.py

@@ -1,91 +0,0 @@
-import random
-
-from loguru import logger
-from sybil_engine.config.app_config import get_cex_data, get_cex_conf
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance_utils import get_native_balance, \
-    interval_to_native_balance, interval_to_erc20_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.domain.cex.binance import Binance
-from sybil_engine.domain.cex.okx import OKX
-from sybil_engine.module.module import Module
-from sybil_engine.utils.app_account_utils import AppAccount
-from sybil_engine.utils.utils import randomized_sleeping, ConfigurationException
-from sybil_engine.utils.web3_utils import init_web3
-
-
-class CEXWithdraw(Module):
-    module_name = 'CEX_WITHDRAW'
-    sleep_after_conf = True
-    module_config = 'cex_withdraw'
-
-    def execute(self, chain, withdraw_interval, min_auto_withdraw_interval, token, cex, account: AppAccount):
-        self.sleep_after_conf = True
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, None)
-
-        balance, min_auto_withdraw, withdraw_token = self.balance(account, chain, chain_instance,
-                                                                  min_auto_withdraw_interval, token, web3)
-        logger.info(f"{chain}")
-        logger.info(f"Minimum balance should be {min_auto_withdraw}")
-
-        if min_auto_withdraw.wei < balance.wei:
-            self.sleep_after_conf = False
-
-        while min_auto_withdraw.wei > balance.wei:
-            logger.info(f"Actual balance: {balance}")
-
-            amount = round(random.uniform(withdraw_interval['from'], withdraw_interval['to']), 6)
-            logger.info(f"Withdraw {amount} {chain_instance['gas_token']} from {cex} to {account.address}")
-
-            password, cex_data = get_cex_data()
-
-            if cex == 'okx':
-                cex_obj = OKX(cex_data[get_cex_conf()], password)
-            elif cex == 'binance':
-                cex_obj = Binance(cex_data[get_cex_conf()], password)
-            else:
-                raise ConfigurationException(f"{cex} is not")
-
-            if withdraw_token == 'WETH':
-                withdraw_token = 'ETH'
-
-            cex_obj.withdrawal(account.address, chain, amount, withdraw_token)
-
-            randomized_sleeping({'from': 60 * 2, 'to': 60 * 4})
-
-            balance, _, _ = self.balance(account, chain, chain_instance, min_auto_withdraw_interval, token, web3)
-
-    def balance(self, account, chain, chain_instance, min_auto_withdraw_interval, token, web3):
-        if token == 'NATIVE':
-            min_auto_withdraw = interval_to_native_balance(min_auto_withdraw_interval, account, chain, web3)
-            balance = get_native_balance(account, web3, chain_instance)
-            withdraw_token = chain_instance['gas_token']
-        elif token in ['USDC', 'USDT', 'WETH', 'ETH']:
-            if token == 'ETH':
-                token = 'WETH'
-            min_auto_withdraw = interval_to_erc20_balance(min_auto_withdraw_interval, account, token, chain, web3)
-            erc20_token = Erc20Token(chain, token, web3)
-            balance = erc20_token.balance(account)
-            withdraw_token = token
-        else:
-            raise ConfigurationException(f"Unsupported token {token}, supported tokens are: NATIVE, USDC")
-        return balance, min_auto_withdraw, withdraw_token
-
-    def log(self):
-        return "CEX WITHDRAW"
-
-    def parse_params(self, module_params):
-        if 'cex' not in module_params:
-            module_params['cex'] = 'okx'
-
-        return [
-            module_params['chain'],
-            module_params['withdraw_interval'],
-            module_params['min_auto_withdraw_interval'],
-            module_params['token'],
-            module_params['cex']
-        ]
-
-    def sleep_after(self):
-        return self.sleep_after_conf

web3_wizzard_lib/core/modules/claimer.py

@@ -1,45 +0,0 @@
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.module.module import Module
-from sybil_engine.utils.app_account_utils import AppAccount
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.modules.claims.layerzero_claimer import claimer_zro
-from web3_wizzard_lib.core.modules.claims.rabby_claimer import claimer_rabby
-
-native_prices = {
-    'ETH': 3700,
-    'USDT': 1
-}
-
-
-class Claimer(Module):
-    module_name = 'CLAIMER'
-    sleep_after_conf = True
-    module_config = 'claimer_config'
-
-    def execute(self, chain, layerzero_token, project, account: AppAccount):
-        logger.info(f"CLAIM L0 tokens for {account} on {chain}")
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, None)
-
-        if project == 'ZRO':
-            claimer_zro(account, chain_instance, layerzero_token, web3)
-        else:
-            claimer_rabby(account, web3)
-
-    def log(self):
-        return "CLAIMER"
-
-    def parse_params(self, module_params):
-        if 'project' not in module_params:
-            module_params['project'] = 'ZRO'
-
-        return [
-            module_params['chain'],
-            module_params['token'],
-            module_params['project']
-        ]
-
-    def sleep_after(self):
-        return self.sleep_after_conf