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

core/modules/bungee.py

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

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

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

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

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

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

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

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

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

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