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

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

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

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

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

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

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

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

core/modules/concrete_swap.py

@@ -1,97 +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_wizzard_lib.core.modules 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)
-
-        pair_to_swap = self.create_pair_to_swap(
-            from_token_contract.symbol(),
-            swap_app,
-            to_token_contract.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']
-        )

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

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