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

web3_wizzard_lib/core/modules/lending_module.py

@@ -0,0 +1,134 @@
+import random
+
+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 NativeBalance
+from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance, from_eth_to_wei, verify_balance
+from sybil_engine.module.module import Order, RepeatableModule
+from sybil_engine.utils.app_account_utils import AppAccount
+from sybil_engine.utils.utils import ConfigurationException, interval_to_round
+from sybil_engine.utils.validation_utils import validate_amount_interval, validate_interval
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.basiliskcontract import BasiliskContract
+from web3_wizzard_lib.core.contract.eralendcontract import EraLendContract
+from web3_wizzard_lib.core.contract.reactor_fusion_contract import ReactorFusionContract
+from web3_wizzard_lib.core.modules.bank.layerbank import LayerBank
+from web3_wizzard_lib.core.modules.bank.aave import Aave
+
+
+class Lending(RepeatableModule):
+    module_name = 'LENDING'
+    module_config = 'lending_config'
+    random_order = Order.RANDOM
+
+    @RepeatableModule.repeatable_log
+    def execute(self, lending_apps, amount: float, action: str, withdraw_sleep_interval: dict, chain,
+                account: AppAccount):
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        lending_app_name = random.choice(lending_apps)
+        lending_app = self.get_lending_app(lending_app_name, chain, web3)
+
+        verify_balance(self.min_native_balance, chain_instance, account, web3)
+
+        if action == 'DEPOSIT':
+            self.deposit(account, amount, lending_app, lending_app_name, chain, web3)
+        elif action == 'WITHDRAW':
+            self.withdraw(account, amount, chain, lending_app, lending_app_name)
+        elif action == 'WITHDRAW_ALL':
+            for app_name, app in self.lending_apps_with_deposit(account, chain, web3):
+                self.withdraw(account, amount, chain, app, app_name)
+        else:
+            raise ConfigurationException("Unsupported action")
+
+    def deposit(self, account, amount, lending_app, lending_app_name, chain, web3):
+        amount_balance = interval_to_eth_balance(amount, account, chain, web3)
+
+        if amount == 'all_balance':
+            amount_balance = amount_balance.minus(self.min_native_balance)
+
+        logger.info(f"Make deposit on {lending_app_name} | {amount_balance}")
+
+        lending_app.mint(account, amount_balance.wei)
+
+    def withdraw(self, account, amount, chain, lending_app, lending_app_name):
+        deposit_balance = NativeBalance(lending_app.get_deposit_amount(account), chain, 'ETH')
+
+        if deposit_balance.wei < 1000000000000:
+            raise EmptyDepositException(f"[{account.address}] Deposit balance is 0, skip")
+
+        logger.info(f"Deposit balance: {deposit_balance}")
+
+        if amount == 'all_balance':
+            withdraw_wei = deposit_balance.wei
+        else:
+            balance = NativeBalance(from_eth_to_wei(interval_to_round(amount)), chain, 'ETH')
+            amount_balance = NativeBalance(int(balance.wei // 10000) * 10000, chain, balance.token)
+            withdraw_wei = amount_balance.wei
+
+            if deposit_balance.wei < withdraw_wei:
+                logger.info(
+                    f"Deposit {deposit_balance} < withdraw amount {amount_balance}"
+                    f", withdrawing all deposit")
+                withdraw_wei = deposit_balance.wei
+
+        logger.info(f"Withdraw from {lending_app_name} | {deposit_balance}")
+
+        lending_app.redeem_underlying(account, withdraw_wei)
+
+    def get_lending_app(self, lending_app, chain, web3):
+        lending_apps = self.get_lending_apps(chain, web3)
+
+        if lending_app not in lending_apps.keys():
+            raise ConfigurationException(f"{lending_app} not supported in {chain}. Supported lending: {list(lending_apps.keys())} supported")
+
+        return lending_apps[lending_app]
+
+    def get_lending_apps(self, chain, web3):
+        contracts = get_contracts_for_chain(chain)
+
+        apps = {
+            'BASILISK_LANDING': BasiliskContract,
+            'REACTORFUSION_LANDING': ReactorFusionContract,
+            'ERALEND': EraLendContract,
+            'AAVE': Aave,
+            'LAYERBANK': LayerBank
+        }
+
+        return {k: v(contracts[k], web3) for k, v in apps.items() if k in contracts}
+
+    def lending_apps_with_deposit(self, account, chain, web3):
+        with_deposit = []
+
+        for lending_app_name, lending_app in self.get_lending_apps(chain, web3).items():
+            if lending_app.get_deposit_amount(account) > 1000000000000:
+                with_deposit.append((lending_app_name, lending_app))
+
+        return with_deposit
+
+    def log(self):
+        return "LENDING"
+
+    def parse_params(self, module_params):
+        validate_amount_interval(module_params['amount'])
+        validate_interval(module_params['withdraw_sleep_interval'])
+
+        if 'chain' not in module_params:
+            module_params['chain'] = 'ZKSYNC'
+
+        return [
+            module_params['lending_apps'],
+            module_params['amount'],
+            module_params['action'],
+            module_params['withdraw_sleep_interval'],
+            module_params['chain']
+        ]
+
+
+class EmptyDepositException(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)

web3_wizzard_lib/core/modules/linea_appeal.py

@@ -0,0 +1,70 @@
+import webbrowser
+
+from loguru import logger
+from sybil_engine.module.module import Module
+import requests
+
+
+class LineaAppeal(Module):
+    module_name = 'LINEA_APPEAL'
+    module_config = None
+
+    # with open("resources/linea_appeal.txt") as f:
+    #     linea_appeal_reason = f.read()
+
+    linea_appeal_reason = """
+        Меня проект Linea забанили акки и пометили как сибила. Планирую писать апелляции с указанием причин почему я не сибил. 
+        Вот список аргументов: 
+        1. Получал дроп LayerZero. 
+        2. Получал дроп ZKsync 
+        3. Получал дроп ODOS 
+        4. Был активен в более чем 10 сетях 
+        5. Потратил 60-100$ на кампании Линея начиная от Defi Voyage 
+        6. Прошел POH 
+        7. Получил дроп Scroll 
+        8. Обьем торгов по аккаунту более 100 тыс$. Возьми составь аргументации для 10 аккаунтов, 
+        выбрав рандомно от 5 до 8 из этих причин для разбана. Все на англ.
+        """
+
+    def execute(self, account, chain="LINEA", statistic_write="GOOGLE"):
+        base_url = "https://docs.google.com/forms/d/e/1FAIpQLSfkbHzC1hZTy6u5R8S5i6wQ2xCyUZQjvucmlyChwg04fJIO5Q/viewform"
+
+        reason = self.get_reason()
+
+        logger.info(reason)
+
+        payload = {
+            "entry.1292139045": account.address,
+            "entry.1099559693": "",
+            "entry.1296389817": reason['choices'][0]['message']['content']
+            # Add other entries based on the form's structure
+        }
+
+        # Build the pre-filled URL
+        query_string = "&".join(f"{key}={value}" for key, value in payload.items())
+        pre_filled_url = f"{base_url}?{query_string}"
+
+        # Open the pre-filled form in the default web browser
+        print(f"Opening form: {pre_filled_url}")
+        webbrowser.open(pre_filled_url)
+
+    def get_reason(self):
+        # logger.info(self.linea_appeal_reason)
+        reason = self.get_chat_gpt(self.linea_appeal_reason)
+        return reason
+
+    def get_chat_gpt(self, linea_appeal_reason):
+        url = "https://api.openai.com/v1/chat/completions"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer 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"
+        }
+        data = {
+            "model": "gpt-4o-mini",
+            "messages": [{"role": "user", "content": linea_appeal_reason}],
+            "temperature": 0.7
+        }
+
+        response = requests.post(url, headers=headers, json=data)
+
+        return response.json()

web3_wizzard_lib/core/modules/linea_poh_lxp.py

@@ -0,0 +1,64 @@
+import requests
+from loguru import logger
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance import Erc20Balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.module.module import Module
+from sybil_engine.utils.accumulator import add_accumulator_balance, add_accumulator, get_value
+from sybil_engine.utils.statistic_utils import statistic_date_string, get_statistic_writer
+from sybil_engine.utils.web3_utils import init_web3
+
+
+class LineaPOHLXP(Module):
+    module_name = 'LINEA_POH_LXP'
+    module_config = None
+
+    lxp_contract = "0xd83af4fbD77f3AB65C3B1Dc4B38D7e67AEcf599A"
+
+    def execute(self, account, chain="LINEA", statistic_write="GOOGLE"):
+        poh = self.linea_poh_passed(account)
+
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+        erc20_token = Erc20Token(chain, self.lxp_contract, web3)
+        balance = erc20_token.balance(account)
+
+        logger.info(f"{account.address} balance is {balance}")
+        job_name = f"lxp_{statistic_date_string}"
+        statistics_writer = get_statistic_writer()
+
+        statistics_writer.init_if_required(
+            job_name,
+            ['#', 'Address', 'rLXP', 'POH', 'LXP', 'Remark']
+        )
+
+        if poh:
+            rLXP = balance
+            add_accumulator_balance("Total rLXP", rLXP.wei)
+        else:
+            rLXP = Erc20Balance(0, 'LINEA', "LXP")
+
+        add_accumulator_balance("Total LXP", balance.wei)
+        add_accumulator("Acc Num", 1)
+
+        row = [account.app_id, account.address, float(rLXP.readable()), poh, float(balance.readable()), ""]
+        statistics_writer.write_row(job_name, row)
+
+        if get_value("Acc Num") == get_value("Acc Amount"):
+            row = [
+                "TOTAL",
+                "",
+                float(get_value("Total rLXP").readable() / 10 ** 12),
+                "",
+                float(get_value("Total LXP").readable() / 10 ** 12),
+                ""
+            ]
+
+            statistics_writer.write_row(job_name, row)
+
+    def linea_poh_passed(self, account):
+        result = requests.get(f"https://linea-xp-poh-api.linea.build/poh/{account.address}").json()
+        return result["poh"]
+
+    def log(self):
+        return "LINEA POH LXP"

web3_wizzard_lib/core/modules/liquidity/nile_pool.py

@@ -0,0 +1,64 @@
+from loguru import logger
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.utils.retry import retry
+
+from web3_wizzard_lib.core.contract.nile_contract import NileContract
+from web3_wizzard_lib.core.modules.liquidity.pool import Pool
+
+
+class NilePool(Pool):
+    pool_contract = 'NILE_POOL'
+
+    def __init__(self, chain_instance, web3):
+        super().__init__(chain_instance, web3)
+        self.nile_contract = NileContract(self.velocore_pool_contract_address, self.web3)
+
+    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
+    def deposit(self, amount_interval, account, token, min_native_balance, chain):
+        amount = interval_to_eth_balance(amount_interval, account, chain, self.web3)
+
+        pool_amount = self.nile_contract.get_amount_out(
+            amount,
+            get_tokens_for_chain(chain)['WETH'],
+            get_tokens_for_chain(chain)[token]
+        )[0]
+
+        nile_token = Erc20Token(chain, token, self.web3)
+
+        if nile_token.allowance(account, self.nile_contract.contract_address) < nile_token.balance(account).wei:
+            nile_token.approve(account, self.nile_contract.contract_address)
+
+        logger.info(f"Deposit {amount} and {nile_token.balance(account)}")
+        self.nile_contract.add_liquidity_eth(account, nile_token.erc20_contract.contract_address, pool_amount, amount)
+
+    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
+    def withdraw(self, account, token, chain):
+        weth_zero_address = get_tokens_for_chain(chain)[f"WETH_{token}_LP"]
+
+        weth_zero = Erc20Token(chain, weth_zero_address, self.web3)
+
+        if weth_zero.balance(account).wei < 10000:
+            logger.info("NILE almost zero balance")
+
+        zero_token_address = get_tokens_for_chain(chain)[token]
+
+        amount = self.nile_contract.quote_remove_liquidity_eth(
+            get_tokens_for_chain(chain)['WETH'],
+            get_tokens_for_chain(chain)[token],
+            weth_zero.balance(account).wei
+        )
+
+        if weth_zero.allowance(account, self.nile_contract.contract_address) < weth_zero.balance(account).wei:
+            weth_zero.approve(account, self.nile_contract.contract_address)
+
+        logger.info(f"Withdraw {token} on NILE {weth_zero.balance(account)}")
+
+        self.nile_contract.remove_liquidity_eth(
+            account,
+            zero_token_address,
+            weth_zero.balance(account).wei,
+            amount[0],
+            amount[1]
+        )

web3_wizzard_lib/core/modules/liquidity/pool.py

@@ -0,0 +1,16 @@
+from sybil_engine.data.contracts import get_contracts_for_chain
+
+
+class Pool:
+    pool_contract = ''
+
+    def __init__(self, chain_instance, web3):
+        self.chain_contracts = get_contracts_for_chain(chain_instance['chain'])
+        self.velocore_pool_contract_address = self.chain_contracts[self.pool_contract]
+        self.web3 = web3
+
+    def deposit(self, amount_interval, account, token, min_native_balance, chain):
+        pass
+
+    def withdraw(self, account, token, chain):
+        pass

web3_wizzard_lib/core/modules/liquidity/syncswap_pool.py

@@ -0,0 +1,61 @@
+from loguru import logger
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.domain.balance.balance import NativeBalance
+from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+
+from web3_wizzard_lib.core.contract.syncswap_pool import SyncSwapPoolContract
+from web3_wizzard_lib.core.contract.syncswap_classic_pool import SyncSwapClassicPool
+from web3_wizzard_lib.core.contract.syncswap_router import SyncSwapRouter
+from web3_wizzard_lib.core.modules.liquidity.pool import Pool
+
+
+class SyncswapPool(Pool):
+    module_name = 'SYNCSWAP_LIQUIDITY'
+    pool_contract = 'SYNCSWAP'
+
+    def __init__(self, chain_instance, web3):
+        super().__init__(chain_instance, web3)
+        self.syncswap_router = SyncSwapRouter(self.velocore_pool_contract_address, self.web3)
+
+    def deposit(self, amount_interval, account, token, min_native_balance, chain):
+        amount = interval_to_eth_balance(amount_interval, account, chain, self.web3)
+
+        pool = self.get_pool(chain)
+        pool_amount = self.get_pool_amount(account, chain, pool)
+
+        if pool_amount.wei < 10000000000:
+            logger.info(f"Deposit {amount}")
+            self.syncswap_router.add_liquidity2(account, amount)
+        else:
+            logger.info("This account already has deposit, skip")
+
+    def withdraw(self, account, token, chain):
+        pool = self.get_pool(chain)
+        pool_amount = self.get_pool_amount(account, chain, pool)
+
+        if pool_amount.wei < 10000000000:
+            logger.info(f"Withdraw amount is to small")
+            return
+
+        erc20_token = Erc20Token(chain, pool, self.web3)
+
+        if erc20_token.allowance(account, self.syncswap_router.contract_address) < pool_amount.wei:
+            erc20_token.approve(account, self.syncswap_router.contract_address)
+
+        print(erc20_token.balance(account).wei)
+
+        logger.info(f"Withdraw {pool_amount}")
+        self.syncswap_router.burn_liquidity(account, pool, pool_amount)
+
+    def get_pool_amount(self, account, chain, pool):
+        return NativeBalance(
+            SyncSwapPoolContract(pool, self.web3).balanceOf(account),
+            chain,
+            'ETH'
+        )
+
+    def get_pool(self, chain):
+        syncswap_classic_pool = SyncSwapClassicPool(get_contracts_for_chain(chain)["SYNCSWAP_CLASSIC_POOL_FACTORY"], self.web3)
+        return syncswap_classic_pool.get_pool(get_tokens_for_chain(chain)['ETH'], get_tokens_for_chain(chain)['USDC'])

web3_wizzard_lib/core/modules/liquidity/velocore_pool.py

@@ -0,0 +1,55 @@
+from loguru import logger
+from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance, interval_to_erc20_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+
+from web3_wizzard_lib.core.contract.velocore_lens import VelocoreLensContract
+from web3_wizzard_lib.core.contract.velocore_pool import VelocorePoolContract
+from web3_wizzard_lib.core.modules.liquidity.pool import Pool
+
+
+class VelocorePool(Pool):
+    module_name = 'VELOCORE_LIQUIDITY'
+    pool_contract = 'VELOCORE_POOL'
+    pool_lens_contract = 'VELOCORE_LENS'
+
+    def __init__(self, chain_instance, web3):
+        super().__init__(chain_instance, web3)
+        self.chain_instance = chain_instance
+        self.velocore_pool = VelocorePoolContract(self.velocore_pool_contract_address, self.web3)
+        self.velocore_lens = VelocoreLensContract('0xaA18cDb16a4DD88a59f4c2f45b5c91d009549e06', self.web3)
+
+    def deposit(self, amount_interval, account, token, min_native_balance, chain):
+        if token == 'ETH':
+            amount = interval_to_eth_balance(amount_interval, account, chain, self.web3)
+
+            if amount_interval == 'all_balance':
+                amount = amount.minus(min_native_balance)
+        else:
+            amount = interval_to_erc20_balance(amount_interval, account, token, chain, self.web3)
+
+            erc20_token = Erc20Token(self.chain_instance['chain'], "wstETH", self.web3)
+
+            if erc20_token.allowance(account, self.velocore_pool.contract_address) < amount.wei:
+                erc20_token.approve(account, self.velocore_pool.contract_address)
+
+        pool_address = '0x2BD146e7d95cea62C89fcCA8E529e06EEc1b053C'
+
+        logger.info(f"Deposit {amount}")
+
+        self.velocore_pool.deposit(account, int(amount.wei * 0.99), token, pool_address)
+
+    def withdraw(self, account, token, chain):
+        pool_address = '0x2BD146e7d95cea62C89fcCA8E529e06EEc1b053C'
+
+        gauge = self.velocore_lens.query_gauge(pool_address, account)
+
+        usdc_eth_vlp = gauge[14]
+        eth = gauge[9]
+
+        logger.info(f"Withdraw {eth / 10 ** 18} ETH")
+
+        if eth / 10 ** 18 < 0.0005:
+            logger.info("Withdraw amount less than 0.0005, skip")
+            return
+
+        self.velocore_pool.withdraw(account, eth, usdc_eth_vlp, pool_address)

web3_wizzard_lib/core/modules/liquidity/zerolend_liquidity.py

@@ -0,0 +1,26 @@
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.utils.retry import retry
+
+from web3_wizzard_lib.core.contract.zerolend_liq_contract import ZeroLendLiqContract
+from web3_wizzard_lib.core.modules.liquidity.pool import Pool
+
+
+class ZeroLendLiquidity(Pool):
+    module_name = 'ZEROLEND_LIQUIDITY'
+    pool_contract = 'ZEROLEND'
+
+    @retry(max_attempts=5, retry_interval={'from': 15 * 1, 'to': 30 * 1})
+    def deposit(self, amount_interval, account, deposit_token, min_native_balance, chain):
+        contract = ZeroLendLiqContract(get_contracts_for_chain(chain)['ZEROLEND'], self.web3)
+
+        zerolend_token = Erc20Token(chain, deposit_token, self.web3)
+
+        amount = interval_to_eth_balance(amount_interval, account, chain, self.web3)
+
+        if zerolend_token.allowance(account, contract.contract_address) < zerolend_token.balance(account).wei:
+            zerolend_token.approve(account, contract.contract_address)
+
+        contract.create_lock(account, amount)
+

web3_wizzard_lib/core/modules/liquidity_pool.py

@@ -0,0 +1,60 @@
+from venv 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.validation_utils import validate_amount_interval
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.modules.liquidity.syncswap_pool import SyncswapPool
+from web3_wizzard_lib.core.modules.liquidity.velocore_pool import VelocorePool
+from web3_wizzard_lib.core.modules.liquidity.nile_pool import NilePool
+from web3_wizzard_lib.core.modules.liquidity.zerolend_liquidity import ZeroLendLiquidity
+
+
+class LiquidityPool(Module):
+    module_name = 'LIQUIDITY_POOL'
+    module_config = 'liquidity_pool'
+
+    def execute(self, action, amount_interval, token, dex, chain, account: AppAccount):
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        if dex == 'syncswap':
+            pool = SyncswapPool(chain_instance, web3)
+        elif dex == 'velocore':
+            pool = VelocorePool(chain_instance, web3)
+        elif dex == 'nile':
+            pool = NilePool(chain_instance, web3)
+        elif dex == 'zerolend':
+            pool = ZeroLendLiquidity(chain_instance, web3)
+        else:
+            raise Exception(f" {dex} Not supported")
+
+        if action == 'DEPOSIT':
+            logger.info(f"Deposit {token} to {dex}")
+            pool.deposit(amount_interval, account, token, self.min_native_balance, chain)
+        elif action == 'WITHDRAW':
+            pool.withdraw(account, token, chain)
+        else:
+            raise Exception(f"{action} action not supported")
+
+    def log(self):
+        return "LIQUIDITY_POOL"
+
+    def parse_params(self, module_params):
+        validate_amount_interval(module_params['amount'])
+
+        return [
+            module_params['action'],
+            module_params['amount'],
+            module_params['token'],
+            module_params['dex'],
+            module_params['chain']
+        ]
+
+
+class EmptyDepositException(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)

web3_wizzard_lib/core/modules/merkly_refuel.py

@@ -0,0 +1,87 @@
+import random
+
+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 interval_to_eth_balance, verify_balance, from_wei_to_eth
+from sybil_engine.module.module import Module
+from sybil_engine.utils.utils import ConfigurationException, randomized_sleeping, print_exception_chain
+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.merkly_minter import MerklyMinter
+from web3_wizzard_lib.core.modules.stargate.l0_data import l0_chain_ids
+
+
+class MerklyRefuel(Module):
+    module_name = 'MERKLY_REFUEL'
+    module_config = 'merkly_refuel_config'
+
+    def execute(self, start_chain, end_chain, chains, refuel_amount_interval, sleeping_interval, account):
+        from_chain_instance = get_chain_instance(start_chain)
+        web3 = init_web3(from_chain_instance, account.proxy)
+
+        if start_chain not in chains or end_chain not in chains:
+            raise ConfigurationException(f"'end_chain' and 'start_start' should be in 'chains'. Actual:"
+                                         f"start_chain: {start_chain} end_chain: {end_chain} chains: {chains}"
+                                         )
+
+        merkly_contract = get_contracts_for_chain(start_chain)['MERKLY']
+        merkly = MerklyMinter(merkly_contract, web3)
+
+        self.shuffle_chain_sequence(start_chain, end_chain, chains)
+
+        logger.info(f"Refuel chain sequence: {chains}")
+
+        for current_chain, next_chain in zip(chains, chains[1:]):
+            native_without_min = verify_balance(self.min_native_balance, from_chain_instance, account, web3)
+
+            amount = interval_to_eth_balance(refuel_amount_interval, account, start_chain, web3)
+
+            if amount.wei > native_without_min.wei:
+                amount = native_without_min
+
+            logger.info(f"Refuel {current_chain} > {next_chain} | {amount}")
+
+            hex_amount = merkly.decimal_to_hex_padded(amount.wei)
+
+            try:
+                fee = merkly.estimate_send_fee(account, l0_chain_ids[next_chain], hex_amount)
+                logger.info(f"L0 Fee: {from_wei_to_eth(fee)} ETH")
+
+                merkly.refuel(account, l0_chain_ids[next_chain], amount.wei, fee)
+                randomized_sleeping(sleeping_interval)
+            except Exception as e:
+                print_exception_chain(e)
+
+    def shuffle_chain_sequence(self, start_chain, end_chain, chain_sequence):
+        if start_chain != '':
+            chain_sequence.remove(start_chain)
+
+        if end_chain != '' and end_chain in chain_sequence:
+            chain_sequence.remove(end_chain)
+
+        random.shuffle(chain_sequence)
+
+        if start_chain != '':
+            chain_sequence.insert(0, start_chain)
+
+        if end_chain != '':
+            chain_sequence.append(end_chain)
+
+        return chain_sequence
+
+    def log(self):
+        return "MERKLY REFUEL"
+
+    def parse_params(self, module_params):
+        validate_chain(module_params['end_chain'])
+        validate_refuel_interval(module_params['refuel_amount_interval'])
+
+        return (
+            module_params['start_chain'],
+            module_params['end_chain'],
+            module_params['chains'],
+            module_params['refuel_amount_interval'],
+            module_params['sleeping_interval']
+        )

web3_wizzard_lib/core/modules/modules.py

@@ -0,0 +1,27 @@
+import importlib
+import pkgutil
+
+from loguru import logger
+from sybil_engine.app import launch_with_data
+from sybil_engine.utils.configuration_loader import load_module_vars
+
+import web3_wizzard_lib.core.modules
+from web3_wizzard_lib.core.modules.swap.swap_list import swap_facade
+
+
+def launch():
+    modules_package = "web3_wizzard_lib.core.modules"
+
+    # package = importlib.import_module(modules_package)
+    # for loader, module_name, is_pkg in pkgutil.walk_packages(path=package.__path__):
+    #     if not is_pkg:
+    #         try:
+    #             importlib.import_module('.' + module_name, package=modules_package)
+    #         except Exception as e:
+    #             logger.error('Failed to import module "{}" from package "{}"'.format(module_name, modules_package))
+
+    #modules_data = load_module_vars(modules_package)['modules_data']
+
+    from sybil_engine.module.modules import Modules
+    modules_data = Modules(None, swap_facade)
+    launch_with_data(modules_data)