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

core/modules/swap/mute.py

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

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

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

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

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

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

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

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

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

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

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

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

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