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

core/modules/swap/mute.py

@@ -1,39 +0,0 @@
-from sybil_engine.domain.dex import Dex
-
-from web3_wizzard_lib.core.contract.mute_router import MuteRouter
-
-
-class Mute(Dex):
-    dex_name = 'mute'
-    swap_contract = "MUTE_ROUTER"
-    supported_chains = ['ZKSYNC']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.weth_address = self.tokens['WETH']
-        mute_contract = self.chain_contracts[self.swap_contract]
-        self.mute_router = MuteRouter(mute_contract, self.web3)
-
-    def swap_native_for_token(self, account, amount_to_swap, slippage, to_token_address):
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, self.weth_address, to_token_address) * slippage)
-
-        args = [account, amount_to_swap, self.weth_address, to_token_address, amount_out_min]
-        func = self.mute_router.swap_exact_eth_for_tokens_supporting_fee_on_transfer_tokens
-        return args, func
-
-    def swap_token_for_native(self, account, amount_to_swap, from_token_address, slippage):
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, from_token_address, self.weth_address) * slippage)
-
-        args = [account, amount_to_swap, from_token_address, self.weth_address, amount_out_min]
-        func = self.mute_router.swap_exact_tokens_for_eth_supporting_fee_on_transfer_tokens
-        return args, func
-
-    def swap_token_for_token(self, account, amount_to_swap, slippage, from_token_address, to_token_address):
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, from_token_address, to_token_address) * slippage)
-
-        args = [account, amount_to_swap, from_token_address, to_token_address, amount_out_min]
-        func = self.mute_router.swap_exact_tokens_for_tokens_supporting_fee_on_transfer_tokens
-        return args, func
-
-    def get_amount_out_min(self, amount_to_swap, from_token_address, to_token_address):
-        return self.mute_router.get_amount_out(amount_to_swap, from_token_address, to_token_address)

core/modules/swap/odos.py

@@ -1,58 +0,0 @@
-from loguru import logger
-from sybil_engine.domain.dex import Dex
-from sybil_engine.utils.retry import retry
-from sybil_engine.utils.utils import AccountException
-
-from web3_wizzard_lib.core.contract.odos import Odos
-
-
-class OdosSwap(Dex):
-    dex_name = 'odos'
-    swap_contract = 'ODOS'
-    supported_chains = ['ZKSYNC', 'BASE', 'LINEA']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.odos_router_contract = self.chain_contracts[self.swap_contract]
-        self.odos_router = Odos(self.odos_router_contract, self.web3)
-
-    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
-    def swap(self, amount_to_swap, from_token, to_token, slippage, account):
-        logger.info(
-            f"Swap {amount_to_swap.log_line()}->{to_token.symbol()} in {self.dex_name} ({self.chain_instance['chain']})")
-
-        if amount_to_swap.token == 'ETH':
-            from_token_address = '0x0000000000000000000000000000000000000000'
-        else:
-            from_token_address = from_token.erc20_contract.contract_address
-
-        if to_token.token == 'ETH':
-            to_token_address = '0x0000000000000000000000000000000000000000'
-        else:
-            to_token_address = to_token.erc20_contract.contract_address
-
-        quote_data = self.odos_router.quote(
-            account, from_token_address, to_token_address, amount_to_swap.wei, slippage, self.chain_instance['chain']
-        )
-
-        if amount_to_swap.token == 'ETH':
-            transaction_data = self.odos_router.assemble(account, quote_data["pathId"])
-
-            func = self.odos_router.swap
-        else:
-            balance = from_token.balance(account)
-
-            if balance.wei < amount_to_swap.wei:
-                raise AccountException(f"Balance {balance} < {amount_to_swap}")
-
-            if from_token.allowance(account, self.odos_router_contract) < amount_to_swap.wei:
-                from_token.approve(account, self.odos_router_contract)
-
-            transaction_data = self.odos_router.assemble(account, quote_data["pathId"])
-
-            if to_token.token == 'ETH':
-                func = self.odos_router.swap
-            else:
-                raise Exception('Not supported')
-
-        func(account, transaction_data)

core/modules/swap/one_inch.py

@@ -1,58 +0,0 @@
-import requests
-from sybil_engine.contract.transaction_executor import evm_transaction
-from sybil_engine.domain.dex import Dex
-from sybil_engine.utils.gas_utils import l1_gas_price
-from sybil_engine.utils.utils import randomized_sleeping, SwapException
-from web3 import Web3
-
-
-class OneInch(Dex):
-    dex_name = '1inch'
-    swap_contract = '1INCH'
-    supported_chains = ['BASE', 'ZKSYNC', 'OPTIMISM', 'ARBITRUM']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.weth_address = self.tokens['WETH']
-        self.base_url = 'https://api.1inch.dev/swap'
-        self.inch_version = 5.2
-
-    @l1_gas_price
-    def swap(self, amount_to_swap, from_token, to_token, slippage, account):
-        if amount_to_swap.wei == 0:
-            raise SwapException(f"Can't swap 0 of {amount_to_swap.token}")
-
-        self.get_txn(account, amount_to_swap, from_token, to_token)
-
-    def get_api_call_data(self, url):
-        response = requests.get(url, headers={'Authorization': "DuagMR3vHpYc9JBNqM0Wx9mSWA7VzwuH"})
-
-        return response.json()
-
-    @evm_transaction
-    def get_txn(self, account, amount_to_swap, from_token, to_token):
-        spender_json = self.get_api_call_data(
-            f'{self.base_url}/v{self.inch_version}/{self.web3.eth.chain_id}/approve/spender')
-        spender = Web3.to_checksum_address(spender_json['address'])
-
-        if from_token.symbol() != 'ETH' and from_token.allowance(account, spender) < amount_to_swap.wei:
-            from_token.approve(account, spender)
-
-        randomized_sleeping({'from': 1, 'to': 5})
-
-        _1inchurl = f"{self.base_url}/v{self.inch_version}/{self.web3.eth.chain_id}/swap?fromTokenAddress={from_token.address()}&toTokenAddress={to_token.address()}&amount={amount_to_swap.wei}&fromAddress={account.address}&slippage=5"
-        json_data = self.get_api_call_data(_1inchurl)
-
-        if json_data is False:
-            raise Exception(json_data['description'])
-
-        contract_txn = json_data['tx']
-        contract_txn['from'] = Web3.to_checksum_address(contract_txn['from'])
-        contract_txn['chainId'] = self.web3.eth.chain_id
-        contract_txn['nonce'] = self.web3.eth.get_transaction_count(account.address)
-        contract_txn['to'] = Web3.to_checksum_address(contract_txn['to'])
-        contract_txn['gasPrice'] = int(contract_txn['gasPrice'])
-        contract_txn['gas'] = int(contract_txn['gas'])
-        contract_txn['value'] = int(contract_txn['value'])
-
-        return contract_txn

core/modules/swap/pancake.py

@@ -1,41 +0,0 @@
-from sybil_engine.domain.dex import Dex
-
-from web3_wizzard_lib.core.contract.pancake_quoter import PancakeQuoter
-from web3_wizzard_lib.core.contract.pancake_router import PancakeRouter
-
-
-class Pancake(Dex):
-    dex_name = 'pancake'
-    swap_contract = "PANCAKE_ROUTER"
-    supported_chains = ['ZKSYNC', 'BASE', 'LINEA', 'ARBITRUM']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.weth_address = self.tokens['WETH']
-        self.pancake_router_contract = self.chain_contracts[self.swap_contract]
-        self.pancake_router = PancakeRouter(self.pancake_router_contract, self.web3)
-
-    def swap_native_for_token(self, account, amount_to_swap, slippage, to_token_address):
-
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, self.weth_address, to_token_address) * slippage)
-        args = [account, amount_to_swap, self.weth_address, to_token_address, amount_out_min]
-        func = self.pancake_router.swap_to_token
-
-        return args, func
-
-    def swap_token_for_native(self, account, amount_to_swap, from_token_address, slippage):
-        amount_out_min = int(
-            self.get_amount_out_min(amount_to_swap, from_token_address, self.weth_address) * slippage)
-
-        args = [account, amount_to_swap, from_token_address, self.weth_address, amount_out_min]
-        func = self.pancake_router.swap_to_eth
-        return args, func
-
-    def swap_token_for_token(self, account, amount_to_swap, slippage, from_token_address, to_token_address):
-        raise Exception('Not supported')
-
-    def get_amount_out_min(self, amount_to_swap, from_token_address, to_token_address):
-        pancake_quoter_contract = self.chain_contracts["PANCAKE_QUOTER"]
-        pancake_quoter = PancakeQuoter(pancake_quoter_contract, self.web3)
-
-        return pancake_quoter.quote_exact_input_single(from_token_address, to_token_address, amount_to_swap.wei)

core/modules/swap/swap_facade.py

@@ -1,10 +0,0 @@
-from sybil_engine.domain.dex import Dex
-from sybil_engine.domain.swap_facade import SwapFacade
-from sybil_engine.utils.package_import_utils import get_all_subclasses, import_all_modules_in_directory
-
-
-def get_swap_classes():
-    import_all_modules_in_directory("core.modules.swap")
-    return get_all_subclasses(Dex)
-
-swap_facade = SwapFacade(get_swap_classes())

core/modules/swap/syncswap.py

@@ -1,62 +0,0 @@
-from sybil_engine.domain.dex import Dex
-
-from web3_wizzard_lib.core.contract.syncswap_classic_pool_factory import SyncSwapClassicPoolFactory
-from web3_wizzard_lib.core.contract.syncswap_pool import SyncSwapPoolContract
-from web3_wizzard_lib.core.contract.syncswap_router import SyncSwapRouter
-
-
-class Syncswap(Dex):
-    dex_name = 'syncswap'
-    swap_contract = 'SYNCSWAP'
-    supported_chains = ['ZKSYNC', 'LINEA', 'SCROLL']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.weth_address = self.tokens['WETH']
-        self.pool_classic_pool_factory_address = self.chain_contracts['SYNCSWAP_CLASSIC_POOL_FACTORY']
-        self.syncswap_contract_address = self.chain_contracts[self.swap_contract]
-        self.syncswap_router = SyncSwapRouter(self.syncswap_contract_address, self.web3)
-
-    def swap_native_for_token(self, account, amount_to_swap, slippage, to_token_address):
-        token_in_data_address = self.weth_address
-        token_in_address = self.tokens['ZERO_ADDRESS']
-
-        amount_out_min = int(
-            self.get_amount_out_min(account, amount_to_swap, token_in_data_address, to_token_address) * slippage
-        )
-
-        args = [
-            account,
-            amount_to_swap,
-            self.weth_address,
-            token_in_address,
-            self.get_pool_address(token_in_data_address, to_token_address),
-            amount_out_min
-        ]
-
-        return args, self.syncswap_router.swap
-
-    def swap_token_for_native(self, account, amount_to_swap, from_token_address, slippage):
-        token_in_data_address = self.tokens[amount_to_swap.token]
-        token_in_address = self.tokens[amount_to_swap.token]
-
-        amount_out_min = int(
-            self.get_amount_out_min(account, amount_to_swap, token_in_data_address, self.weth_address) * slippage)
-
-        args = [account, amount_to_swap, token_in_address, token_in_data_address, self.get_pool_address(token_in_data_address, self.weth_address), amount_out_min]
-
-        return args, self.syncswap_router.swap
-
-    def get_amount_out_min(self, account, amount_to_swap, token_in_data_address, to_token_address):
-        pool_address = self.get_pool_address(token_in_data_address, to_token_address)
-
-        if isinstance(pool_address, str):
-            syncswap_pool = SyncSwapPoolContract(pool_address, self.web3)
-        else:
-            syncswap_pool = SyncSwapPoolContract(list(pool_address.items())[0][1], self.web3)
-
-        return syncswap_pool.get_amount_out(account, amount_to_swap, token_in_data_address)
-
-    def get_pool_address(self, token_in_data_address, to_token_address):
-        pool_factory = SyncSwapClassicPoolFactory(self.pool_classic_pool_factory_address, self.web3)
-        return pool_factory.get_pool(token_in_data_address, to_token_address)

core/modules/swap/velocore.py

@@ -1,40 +0,0 @@
-from sybil_engine.domain.dex import Dex
-
-from web3_wizzard_lib.core.contract.velocore_router import VelocoreRouter
-
-
-class Velocore(Dex):
-    dex_name = 'velocore'
-    swap_contract = "VELOCORE_ROUTER"
-    supported_chains = ['ZKSYNC']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.weth_address = self.tokens['WETH']
-        self.velocore_router = VelocoreRouter(self.chain_contracts[self.swap_contract], self.web3)
-
-    def swap_native_for_token(self, account, amount_to_swap, slippage, to_token_address):
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, self.weth_address, to_token_address) * slippage)
-
-        args = [account, amount_to_swap, self.weth_address, to_token_address, amount_out_min]
-        func = self.velocore_router.swap_exact_eth_for_tokens
-
-        return args, func
-
-    def get_amount_out_min(self, amount_to_swap, from_token_address, to_token_address):
-        return self.velocore_router.get_amount_out(amount_to_swap, from_token_address, to_token_address)
-
-    def swap_token_for_native(self, account, amount_to_swap, from_token_address, slippage):
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, from_token_address, self.weth_address) * slippage)
-
-        args = [account, amount_to_swap, from_token_address, self.weth_address, amount_out_min]
-        func = self.velocore_router.swap_exact_tokens_for_eth
-        return args, func
-
-    def swap_token_for_token(self, account, amount_to_swap, slippage, from_token_address, to_token_address):
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, from_token_address, to_token_address) * slippage)
-
-        args = [account, amount_to_swap, from_token_address, to_token_address, amount_out_min]
-        func = self.velocore_router.swap_exact_tokens_for_tokens
-
-        return args, func

core/modules/swap/woofi.py

@@ -1,38 +0,0 @@
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.domain.dex import Dex
-from sybil_engine.utils.gas_utils import l1_gas_price
-from sybil_engine.utils.utils import AccountException
-
-from web3_wizzard_lib.core.contract.woofi_swap import WoofiSwap
-
-
-class Woofi(Dex):
-    dex_name = 'woofi'
-    swap_contract = 'WOOFI'
-    supported_chains = ['ZKSYNC', 'BASE', 'LINEA']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.contract_address = self.chain_contracts[self.swap_contract]
-        self.woofi_swap = WoofiSwap(self.contract_address, self.web3)
-
-    @l1_gas_price
-    def swap(self, amount_to_swap, from_token, to_token, slippage, account):
-        if amount_to_swap.wei == 0:
-            raise AccountException(f"{amount_to_swap.token} balance is 0")
-
-        token_in_address = self.tokens[amount_to_swap.token]
-        token_out_address = self.tokens[to_token.token]
-
-        erc20_from_token = Erc20Token(self.chain_instance['chain'], amount_to_swap.token, self.web3)
-
-        if amount_to_swap.token != 'ETH':
-            if erc20_from_token.allowance(account, self.contract_address) < amount_to_swap.wei:
-                erc20_from_token.approve(account, self.contract_address)
-
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, token_in_address, token_out_address) * slippage)
-
-        self.woofi_swap.swap(account, amount_to_swap, token_in_address, token_out_address, amount_out_min)
-
-    def get_amount_out_min(self, amount_to_swap, token_in_address, token_out_address):
-        return self.woofi_swap.query_swap(token_in_address, token_out_address, amount_to_swap)

core/modules/swap/xy_finance.py

@@ -1,43 +0,0 @@
-from loguru import logger
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.domain.dex import Dex
-from sybil_engine.utils.gas_utils import l1_gas_price
-from sybil_engine.utils.utils import AccountException
-
-from web3_wizzard_lib.core.contract.xy_finance_contract import XYSwapContract
-
-
-class XyFinance(Dex):
-    dex_name = 'xy.finance'
-    swap_contract = 'XY_FINANCE'
-    supported_chains = ['SCROLL']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.contract_address = self.chain_contracts[self.swap_contract]
-        self.xy_swap_contract = XYSwapContract(self.contract_address, self.web3)
-
-    @l1_gas_price
-    def swap(self, amount_to_swap, from_token, to_token, slippage, account):
-        if amount_to_swap.wei == 0:
-            raise AccountException(f"{amount_to_swap.token} balance is 0")
-
-        token_in_address = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" if from_token == "ETH" else self.tokens[from_token]
-        token_out_address = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" if to_token == "ETH" else self.tokens[to_token]
-
-        logger.info(f"Swap {amount_to_swap.log_line()}->{to_token} in {self.dex_name} ({self.chain_instance['chain']})")
-
-        erc20_from_token = Erc20Token(self.chain_instance['chain'], amount_to_swap.token, self.web3)
-
-        if amount_to_swap.token != 'ETH':
-            if erc20_from_token.allowance(account, self.contract_address) < amount_to_swap.wei:
-                erc20_from_token.approve(account, self.contract_address)
-
-        slippage = int((1 - slippage) * 100)
-
-        amount_out_min = self.get_amount_out_min(amount_to_swap, token_in_address, token_out_address, slippage)
-
-        self.xy_swap_contract.swap(account, amount_to_swap, token_in_address, token_out_address, amount_out_min, slippage)
-
-    def get_amount_out_min(self, amount_to_swap, token_in_address, token_out_address, slippage):
-        return self.xy_swap_contract.get_quote(token_in_address, token_out_address, amount_to_swap, slippage)

core/modules/swap/zebra.py

@@ -1,32 +0,0 @@
-from sybil_engine.domain.dex import Dex
-
-from web3_wizzard_lib.core.contract.zebra_contract import ZebraContract
-
-
-class Zebra(Dex):
-    dex_name = 'zebra'
-    swap_contract = "ZEBRA"
-    supported_chains = ['SCROLL']
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.weth_address = self.tokens['WETH']
-        zebra_contract = self.chain_contracts[self.swap_contract]
-        self.zebra = ZebraContract(zebra_contract, self.web3)
-
-    def swap_native_for_token(self, account, amount_to_swap, slippage, to_token_address):
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, self.tokens['ETH'], to_token_address) * slippage)
-
-        args = [account, amount_to_swap, self.tokens['ETH'], to_token_address, amount_out_min]
-        func = self.zebra.swap_to_token
-        return args, func
-
-    def swap_token_for_native(self, account, amount_to_swap, from_token_address, slippage):
-        amount_out_min = int(self.get_amount_out_min(amount_to_swap, from_token_address, self.weth_address) * slippage)
-
-        args = [account, amount_to_swap, from_token_address, self.tokens['ETH'], amount_out_min]
-        func = self.zebra.swap_to_eth
-        return args, func
-
-    def get_amount_out_min(self, amount_to_swap, from_token_address, to_token_address):
-        return self.zebra.get_min_amount_out(amount_to_swap, from_token_address, to_token_address)

core/modules/warm_up.py

@@ -1,98 +0,0 @@
-import random
-
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.data.pairs import Pairs
-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 Order, RepeatableModule
-from sybil_engine.utils.utils import interval_to_int, randomized_sleeping, SwapException
-from sybil_engine.utils.validation_utils import validate_amount_interval_possible_empty, validate_token, \
-    validate_interval, validate_dex_list
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.modules import swap_facade
-
-
-class WarmUp(RepeatableModule):
-    module_name = 'WARMUP'
-    module_config = 'warmup_config'
-    allowed_chains = ['ZKSYNC', 'LINEA', 'BASE', 'SCROLL', 'ARBITRUM']
-    random_order = Order.RANDOM
-    repeat_conf = 'amount_of_warmups'
-
-    @RepeatableModule.repeatable_log
-    def execute(self, chain, swap_amount_interval, warm_token, amount_of_warmups, allowed_dex, pair_names: list,
-                sell_tokens, sleep_interval, account):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        swap_amount = interval_to_int(amount_of_warmups)
-
-        if len(pair_names) > 0:
-            logger.info(f"Warmup pairs {pair_names}")
-
-        pair = Pairs(swap_facade)
-
-        pair_swaps = pair.get_warmup_pair_swaps(allowed_dex, chain, pair_names, swap_amount, warm_token)
-        random.shuffle(pair_swaps)
-        self._warm_up(chain_instance, pair_swaps, sell_tokens, sleep_interval, swap_amount_interval, account, web3)
-
-    def _warm_up(self, chain_instance, pair_swaps, sell_tokens, sleep_interval, swap_amount_interval, account, web3):
-        pair, swaps = random.choice(pair_swaps)
-        random.shuffle(swaps)
-
-        native_balance = verify_balance(self.min_native_balance, chain_instance, account, web3)
-        buy_dex, sell_dex = swaps[0], swaps[-1]
-
-        self._warm_up_pair(buy_dex, sell_dex, native_balance, swap_amount_interval, chain_instance, pair, sell_tokens,
-                           sleep_interval, account, web3)
-
-        randomized_sleeping(sleep_interval)
-
-    def _warm_up_pair(self, buy_dex, sell_dex, native_balance, swap_amount_interval, chain_instance, pair, sell_tokens,
-                      sleep_interval, account, web3):
-        warm_up_token = pair['tokens'][0]
-        token = pair['tokens'][1]
-
-        amount_to_swap = amount_to_swap_from_interval(account, chain_instance['chain'], self.min_native_balance,
-                                                      native_balance, swap_amount_interval, warm_up_token, web3)
-        swap_facade.swap(account, amount_to_swap, chain_instance, pair, buy_dex, warm_up_token, token, web3)
-        randomized_sleeping(sleep_interval)
-
-        if sell_tokens:
-            try:
-                self.execute_sell(chain_instance, pair, sell_dex, account, web3)
-            except SwapException as e:
-                logger.error(e)
-                self.execute_sell(chain_instance, pair, buy_dex, account, web3)
-
-    def execute_sell(self, chain_instance, pair, sell_dex, account, web3):
-        amount_to_swap = Erc20Token(chain_instance['chain'], pair['tokens'][1], web3).balance(account)
-        swap_facade.swap(account, amount_to_swap, chain_instance, pair, sell_dex, amount_to_swap.token,
-                         pair['tokens'][0], web3)
-
-    def parse_params(self, module_params):
-        self.validate_supported_chain(module_params['chain'])
-        validate_amount_interval_possible_empty(module_params["swap_amount_interval"])
-        validate_token(module_params["token"])
-        validate_interval(module_params["amount_of_warmups"])
-        validate_dex_list(module_params["allowed_dex"])
-        validate_interval(module_params["pair_sleep_interval"])
-
-        return (
-            module_params["chain"],
-            module_params["swap_amount_interval"],
-            module_params["token"],
-            module_params["amount_of_warmups"],
-            module_params["allowed_dex"],
-            module_params["warmup_pairs"],
-            module_params["sell_tokens"],
-            module_params["pair_sleep_interval"]
-        )
-
-    def log(self):
-        return "WARM UP"
-
-    def sleep_after(self):
-        return False

core/modules/wrapping.py

@@ -1,74 +0,0 @@
-from loguru import logger
-from sybil_engine.contract.weth import WETH
-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_eth_balance, verify_balance, interval_to_weth_balance
-from sybil_engine.module.module import Module
-from sybil_engine.utils.utils import ConfigurationException
-from sybil_engine.utils.validation_utils import validate_amount_interval
-from sybil_engine.utils.web3_utils import init_web3
-
-
-class Wrapping(Module):
-    module_name = 'WRAPPING'
-    module_config = 'wrap_config'
-    allowed_chains = ['ZKSYNC', 'LINEA', 'BASE', 'SCROLL', 'ARBITRUM']
-    sleep_after_var = True
-
-    def execute(self, wrapping_chain, swap_amount_interval, action, account):
-        self.sleep_after_var = True
-        chain_instance = get_chain_instance(wrapping_chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        weth_contract = get_tokens_for_chain(chain_instance['chain'])['WETH']
-        weth = WETH(weth_contract, web3)
-
-        if action == 'WRAP':
-            amount_to_wrap = interval_to_eth_balance(swap_amount_interval, account, chain_instance['chain'], web3)
-
-            logger.info(f"{action} {str(amount_to_wrap)}")
-
-            native_balance = verify_balance(self.min_native_balance, chain_instance, account, web3)
-
-            if swap_amount_interval == 'all_balance':
-                amount_to_wrap = amount_to_wrap.minus(self.min_native_balance)
-
-            if amount_to_wrap.wei > native_balance.wei:
-                raise NotEnoughNativeBalance(
-                    f"Account balance {native_balance} < {amount_to_wrap} amount to wrap.")
-
-            weth.deposit(account, amount_to_wrap)
-        elif action == 'UNWRAP':
-            if swap_amount_interval == '':
-                swap_amount_interval = 'all_balance'
-
-            amount_to_unwrap = interval_to_weth_balance(
-                swap_amount_interval,
-                account,
-                chain_instance['chain'],
-                web3
-            )
-
-            if amount_to_unwrap.wei < 1000:
-                logger.info(f"WETH balance is {amount_to_unwrap}, skip unwrapping")
-                self.sleep_after_var = False
-                return
-
-            logger.info(f"{action} {amount_to_unwrap}")
-
-            weth.withdraw(account, amount_to_unwrap)
-        else:
-            raise ConfigurationException(f'Wrong Action {action}')
-
-    def parse_params(self, module_params):
-        self.validate_supported_chain(module_params['chain'])
-        validate_amount_interval(module_params['amount_interval'])
-
-        return module_params['chain'], module_params['amount_interval'], module_params['action']
-
-    def log(self):
-        return "WRAPPING"
-
-    def sleep_after(self):
-        return self.sleep_after_var

core/modules/zkdx.py

@@ -1,63 +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_utils import interval_to_erc20_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.module.module import Module
-from sybil_engine.utils.app_account_utils import AppAccount
-from sybil_engine.utils.utils import AccountException
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.zkdx_contract import ZKDXContract
-from web3_wizzard_lib.core.contract.zkdx_data import ZKDXDataContract
-
-
-class ZKDX(Module):
-    module_name = 'ZKDX'
-    module_config = 'zkdx_config'
-
-    def execute(self, action, amount_interval, account: AppAccount, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        zkdx_contract = get_contracts_for_chain(chain)['ZKDX']
-        zkdx_data_contract = get_contracts_for_chain(chain)['ZKDX_DATA']
-
-        zkdx = ZKDXContract(zkdx_contract, web3)
-
-        if action == 'DEPOSIT':
-            amount = interval_to_erc20_balance(amount_interval, account, 'USDC', chain, web3)
-
-            erc20 = Erc20Token(chain, 'USDC', web3)
-
-            if erc20.allowance(account, zkdx_contract) < erc20.balance(account).wei:
-                erc20.approve(account, zkdx_contract)
-
-            logger.info(f"Deposit {amount} to ZKDX")
-            zkdx.swap_to_zkdx(account, amount)
-        if action == 'WITHDRAW':
-            zkdx_data = ZKDXDataContract(zkdx_data_contract, web3)
-            balance = zkdx_data.get_balance(account)[0]
-
-            if balance == 0:
-                raise AccountException("ZKDX Balance is 0, skip")
-
-            logger.info(f"WITHDRAW {balance / 10 ** 18} ZUSD to ZKDX")
-            zkdx.swap_from_zkdx(account, balance)
-        else:
-            raise Exception(f"{action} action not supported")
-
-    def log(self):
-        return "ZKDX"
-
-    def parse_params(self, module_params):
-        return [
-            module_params['action'],
-            module_params['amount_interval']
-        ]
-
-
-class EmptyDepositException(Exception):
-    def __init__(self, message):
-        self.message = message
-        super().__init__(self.message)