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

tests/core/modules/swap/test_odos.py

@@ -0,0 +1,36 @@
+import unittest
+
+from tests.core.modules import init_set_test_config
+
+
+class TestOdos(unittest.TestCase):
+    init_set_test_config()
+
+    # def test_odosShouldSwap(self, chain='ZKSYNC'):
+    #     logger.info("Test odos")
+    #
+    #     chain_instance = get_chain_instance(chain)
+    #     web3 = init_web3(chain_instance, None)
+    #
+    #     logger.info(get_native_balance(zksync_test_account, web3, chain_instance))
+    #
+    #     odos = OdosSwap(chain_instance, web3)
+    #
+    #     odos.swap(
+    #         NativeBalance(10000, chain, 'ETH'),
+    #         'ETH',
+    #         'USDC',
+    #         25,
+    #         base_test_account
+    #     )
+    #
+    #     amount_to_swap = Erc20Token(chain, 'USDC', web3).balance(zksync_test_account)
+    #
+    #
+    #     odos.swap(
+    #         amount_to_swap,
+    #         'LIN',
+    #         'ETH',
+    #         0.98,
+    #         base_test_account
+    #     )

tests/core/modules/swap/test_pancake.py

@@ -0,0 +1,54 @@
+import unittest
+
+from loguru import logger
+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 from_eth_to_wei
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.modules import Pancake
+from tests.core.modules import zksync_test_account, test_account, init_set_test_config
+
+
+class TestPancake(unittest.TestCase):
+    init_set_test_config()
+
+    def test_pancakeShouldSwap(self, chains=[
+        ('ZKSYNC', zksync_test_account),
+        ('BASE', test_account),
+        ('LINEA', test_account),
+        ('ARBITRUM', test_account),
+    ], token='USDC'):
+        logger.info("Test pancake")
+
+        for chain, account in chains:
+            chain_instance = get_chain_instance(chain)
+            web3 = init_web3(chain_instance, None)
+
+            native_balance_to_sell = NativeBalance(from_eth_to_wei(1), chain, 'ETH')
+
+            pancake = Pancake(chain_instance, web3)
+
+            pancake.swap(native_balance_to_sell, 'ETH', token, 0.01, account)
+            amount_to_swap = Erc20Token(chain_instance['chain'], token, web3).balance(account)
+            logger.info(f"{native_balance_to_sell} > {amount_to_swap}")
+            pancake.swap(amount_to_swap, token, 'ETH', 0.01, account)
+
+    def test_pancakeShouldSwapUSDT(self, chains=[
+        ('ZKSYNC', zksync_test_account),
+    ], token='USDT'):
+        logger.info("Test mute")
+
+        for chain, account in chains:
+            chain_instance = get_chain_instance(chain)
+            web3 = init_web3(chain_instance, None)
+
+            native_balance_to_sell = NativeBalance(from_eth_to_wei(1), chain, 'ETH')
+
+            mute = Pancake(chain_instance, web3)
+
+            mute.swap(native_balance_to_sell, 'ETH', token, 0.01, account)
+            amount_to_swap = Erc20Token(chain_instance['chain'], token, web3).balance(account)
+            logger.info(f"{native_balance_to_sell} > {amount_to_swap}")
+            mute.swap(amount_to_swap, token, 'ETH', 0.01, account)

tests/core/modules/swap/test_syncswap.py

@@ -0,0 +1,59 @@
+import unittest
+
+from loguru import logger
+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 from_eth_to_wei
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.modules import Syncswap
+from tests.core.modules import zksync_test_account, init_set_test_config, test_account
+
+
+class TestSyncswap(unittest.TestCase):
+    init_set_test_config()
+
+    def test_syncswapShouldSwap(self, chain='ZKSYNC', account=zksync_test_account):
+        logger.info("Test syncswap")
+
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, None)
+
+        native_balance = NativeBalance(from_eth_to_wei(1), chain, 'ETH')
+
+        syncswap = Syncswap(chain_instance, web3)
+        syncswap.swap(native_balance, 'ETH', 'USDC', 0.98, account)
+        amount_to_swap = Erc20Token(chain, 'USDC', web3).balance(account)
+        syncswap.swap(amount_to_swap, 'USDC', 'ETH', 0.98, account)
+
+        syncswap = Syncswap(chain_instance, web3)
+        syncswap.swap(native_balance, 'ETH', 'USDT', 0.98, account)
+        amount_to_swap = Erc20Token(chain, 'USDT', web3).balance(account)
+        syncswap.swap(amount_to_swap, 'USDT', 'ETH', 0.98, account)
+
+        syncswap = Syncswap(chain_instance, web3)
+        syncswap.swap(native_balance, 'ETH', 'WBTC', 0.98, account)
+        amount_to_swap = Erc20Token(chain, 'WBTC', web3).balance(account)
+        syncswap.swap(amount_to_swap, 'WBTC', 'ETH', 0.98, account)
+
+    def test_syncswapShouldSwapForLinea(self, chain='LINEA', account=test_account):
+        logger.info("Test syncswap")
+
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, None)
+
+        native_balance = NativeBalance(from_eth_to_wei(0.1), chain, 'ETH')
+
+        syncswap = Syncswap(chain_instance, web3)
+        syncswap.swap(native_balance, 'ETH', 'USDC', 0.98, account)
+        amount_to_swap = Erc20Token(chain, 'USDC', web3).balance(account)
+        syncswap.swap(amount_to_swap, 'USDC', 'ETH', 0.98, account)
+
+        syncswap = Syncswap(chain_instance, web3, {
+            "ETH>USDC": "0x5Ec5b1E9b1Bd5198343ABB6E55Fb695d2F7Bb308",
+            "USDC>USDT": "0x258d5f860B11ec73Ee200eB14f1b60A3B7A536a2"
+        })
+        syncswap.swap(native_balance, 'ETH', 'USDT', 0.98, account)
+        amount_to_swap = Erc20Token(chain, 'USDT', web3).balance(account)
+        syncswap.swap(amount_to_swap, 'USDT', 'ETH', 0.98, account)

tests/core/modules/swap/test_velocore.py

@@ -0,0 +1,33 @@
+import unittest
+
+from loguru import logger
+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 from_eth_to_wei
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.modules import Velocore
+from tests.core.modules import local_evm_test_account, init_set_test_config
+
+
+class TestVelocore(unittest.TestCase):
+    init_set_test_config()
+
+    def test_velocoreShouldSwap(self, chain='ZKSYNC'):
+        logger.info("Test velocore")
+
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, None)
+
+        velocore = Velocore(chain_instance, web3)
+
+        native_balance_to_swap = NativeBalance(from_eth_to_wei(1), chain, 'ETH')
+
+        velocore.swap(native_balance_to_swap, 'ETH', 'USDC', 0.98, local_evm_test_account)
+        amount_to_swap = Erc20Token(chain_instance['chain'], 'USDC', web3).balance(local_evm_test_account)
+        velocore.swap(amount_to_swap, 'USDC', 'ETH', 0.98, local_evm_test_account)
+
+        velocore.swap(native_balance_to_swap, 'ETH', 'WBTC', 0.98, local_evm_test_account)
+        amount_to_swap = Erc20Token(chain_instance['chain'], 'WBTC', web3).balance(local_evm_test_account)
+        velocore.swap(amount_to_swap, 'WBTC', 'ETH', 0.98, local_evm_test_account)

tests/core/modules/swap/test_woofi.py

@@ -0,0 +1,22 @@
+import unittest
+
+from tests.core.modules import init_set_test_config
+
+
+class TestWoofi(unittest.TestCase):
+    init_set_test_config()
+
+    # def test_woofiShouldSwap(self, chain='ZKSYNC', account=zksync_test_account, token='USDC'):
+    #     logger.info("Test woofi")
+    #
+    #     chain_instance = get_chain_instance(chain)
+    #     web3 = init_web3(chain_instance, None)
+    #
+    #     woofi = Woofi(chain_instance, web3)
+    #     native_balance_to_sell = NativeBalance(from_eth_to_wei(1), chain, 'ETH')
+    #     woofi.swap(native_balance_to_sell, 'ETH', token, 0.95, account)
+    #
+    #     amount_to_swap = Erc20Token(chain, token, web3).balance(account)
+    #     logger.info(f"{native_balance_to_sell} > {amount_to_swap}")
+    #
+    #     woofi.swap(amount_to_swap, token, 'ETH', 0.95, account)

tests/core/modules/test_bungee.py

@@ -0,0 +1,27 @@
+import unittest
+
+from loguru import logger
+
+from web3_wizzard_lib.core.modules import BungeeRefuel
+from tests.core.modules.__init__ import local_evm_test_account, zksync_min_native_balance, init_set_test_config
+
+bungee_test_params = {
+    'from_chain': 'ZKSYNC',
+    'to_chain': 'BASE',
+    'refuel_amount_interval': 'max'
+}
+
+
+class TestBungeeModule(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldRefuelZksyncToBase(self):
+        logger.info("Test module [BUNGEE, 11]")
+
+        try:
+            bungee = BungeeRefuel(zksync_min_native_balance, local_evm_test_account)
+
+            bungee.execute(*bungee.parse_params(bungee_test_params), local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+

tests/core/modules/test_concrete_swap.py

@@ -0,0 +1,62 @@
+import unittest
+
+from loguru import logger
+from sybil_engine.domain.balance.balance import NotEnoughERC20Balance
+
+from web3_wizzard_lib.core.modules import ConcreteSwap
+from tests.core.modules.__init__ import zksync_min_native_balance, init_set_test_config, \
+    local_evm_test_account
+
+
+def create_swap_config(app, chain, from_token, to_token, amount_interval={'from': 1, 'to': 1}):
+    return {
+        'chain': chain,
+        'app': app,
+        'from_token': from_token,
+        'to_token': to_token,
+        'amount_interval': amount_interval
+    }
+
+
+class TestConcreteSwapModule(unittest.TestCase):
+
+    def test_syncswapShouldSwapInZKSync(self, chain='ZKSYNC', app='syncswap'):
+        logger.info("Test module [CONCRETE_SWAP, 3]")
+
+        init_set_test_config()
+
+        concrete_swap = ConcreteSwap(zksync_min_native_balance, local_evm_test_account)
+
+        test_config_buy_usdc = create_swap_config(app, chain, 'ETH', 'USDC')
+        test_config_sell_usdc = create_swap_config(app, chain, 'USDC', 'ETH', 'all_balance')
+        test_config_buy_usdt = create_swap_config(app, chain, 'ETH', 'USDT')
+        test_config_sell_usdt = create_swap_config(app, chain, 'USDT', 'ETH', 'all_balance')
+        test_config_buy_wbtc = create_swap_config(app, chain, 'ETH', 'WBTC')
+        test_config_sell_wbtc = create_swap_config(app, chain, 'WBTC', 'ETH', 'all_balance')
+
+        try:
+            concrete_swap.execute(*concrete_swap.parse_params(test_config_buy_usdc), local_evm_test_account)
+            concrete_swap.execute(*concrete_swap.parse_params(test_config_sell_usdc), local_evm_test_account)
+            concrete_swap.execute(*concrete_swap.parse_params(test_config_buy_usdt), local_evm_test_account)
+            concrete_swap.execute(*concrete_swap.parse_params(test_config_sell_usdt), local_evm_test_account)
+            concrete_swap.execute(*concrete_swap.parse_params(test_config_buy_wbtc), local_evm_test_account)
+            concrete_swap.execute(*concrete_swap.parse_params(test_config_sell_wbtc), local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldThrowNotEnoughERC20Exception(self):
+        logger.info("Test module [CONCRETE_SWAP, 3]")
+
+        init_set_test_config()
+
+        swap_test_config = create_swap_config('syncswap', 'ZKSYNC', 'USDC', 'ETH', 'all_balance')
+
+        concrete_swap = ConcreteSwap(zksync_min_native_balance, local_evm_test_account)
+
+        with self.assertRaises(NotEnoughERC20Balance):
+            concrete_swap.execute(*concrete_swap.parse_params(swap_test_config), local_evm_test_account)
+
+
+
+
+

tests/core/modules/test_dmail.py

@@ -0,0 +1,41 @@
+import unittest
+
+from loguru import logger
+from sybil_engine.domain.account_storage import AccountStorage
+from sybil_engine.utils.utils import ConfigurationException
+
+from web3_wizzard_lib.core.modules import Dmail
+from tests.core.modules.__init__ import init_set_test_config, test_min_native_balance, local_evm_test_account
+
+
+class TestDmailModule(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldSendDmail(self, chains=['LINEA', 'SCROLL']):
+        logger.info("Test module [DMAIL, 5]")
+
+        for chain in chains:
+            send_dmail_test_config = {
+                'chain': chain,
+                'email_amount': {'from': 3, 'to': 4}
+            }
+
+            try:
+                dmail = Dmail(test_min_native_balance, AccountStorage(), range(3))
+
+                dmail.execute(*dmail.parse_params(send_dmail_test_config), local_evm_test_account)
+            except Exception as e:
+                self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldThrowConfigurationExceptionOnUnsupportedChain(self, chains=['ARBITRUM']):
+        logger.info("Test module [DMAIL, 5]")
+
+        for chain in chains:
+            send_dmail_test_config = {
+                'chain': chain,
+                'email_amount': {'from': 3, 'to': 4}
+            }
+            dmail = Dmail(test_min_native_balance, AccountStorage(), range(3))
+
+            with self.assertRaises(ConfigurationException):
+                dmail.parse_params(send_dmail_test_config)

tests/core/modules/test_lending.py

@@ -0,0 +1,122 @@
+import unittest
+
+from loguru import logger
+from sybil_engine.domain.account_storage import AccountStorage
+
+from web3_wizzard_lib.core.modules import Lending, EmptyDepositException
+from tests.core.modules.__init__ import local_evm_test_account, zksync_min_native_balance, init_set_test_config
+
+withdraw_interval = {'from': 60 * 15, 'to': 60 * 60}
+
+
+class TestLending(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldDepositAndWithdraw(self):
+        logger.info("Test module [LENDING]")
+
+        lending_deposit_test_config = {
+            'amount': {'from': 0.001, 'to': 0.001},
+            'action': 'DEPOSIT',
+            'lending_apps': ['ERALEND'],
+            'withdraw_sleep_interval': withdraw_interval
+        }
+
+        lending_withdraw_test_config = {
+            'amount': {'from': 0.001, 'to': 0.001},
+            'action': 'WITHDRAW',
+            'lending_apps': ['ERALEND'],
+            'withdraw_sleep_interval': withdraw_interval
+        }
+
+        lending = Lending(zksync_min_native_balance, AccountStorage(), 1)
+
+        lending.execute(*lending.parse_params(lending_deposit_test_config), local_evm_test_account)
+        lending.execute(*lending.parse_params(lending_withdraw_test_config), local_evm_test_account)
+
+    def test_shouldDepositAndWithdrawAll(self):
+        logger.info("Test module [LENDING]")
+
+        lending_deposit_test_config_eralend = {
+            'amount': {'from': 0.001, 'to': 0.001},
+            'action': 'DEPOSIT',
+            'lending_apps': ['ERALEND'],
+            'withdraw_sleep_interval': withdraw_interval
+        }
+        lending_deposit_test_config_fusion = {
+            'amount': {'from': 0.001, 'to': 0.001},
+            'action': 'DEPOSIT',
+            'lending_apps': ['REACTORFUSION_LANDING'],
+            'withdraw_sleep_interval': withdraw_interval
+        }
+        lending_deposit_test_config_basilisk = {
+            'amount': {'from': 0.001, 'to': 0.001},
+            'action': 'DEPOSIT',
+            'lending_apps': ['BASILISK_LANDING'],
+            'withdraw_sleep_interval': withdraw_interval
+        }
+
+        lending_withdraw_test_config = {
+            'amount': {'from': 0.001, 'to': 0.001},
+            'action': 'WITHDRAW_ALL',
+            'lending_apps': ['ERALEND'],
+            'withdraw_sleep_interval': withdraw_interval
+        }
+
+        lending = Lending(zksync_min_native_balance, AccountStorage(), 1)
+
+        lending.execute(*lending.parse_params(lending_deposit_test_config_basilisk), local_evm_test_account)
+        lending.execute(*lending.parse_params(lending_deposit_test_config_eralend), local_evm_test_account)
+        lending.execute(*lending.parse_params(lending_deposit_test_config_fusion), local_evm_test_account)
+
+        lending.execute(*lending.parse_params(lending_withdraw_test_config), local_evm_test_account)
+
+    def test_shouldFailToWithdraw0(self):
+        logger.info("Test module [LENDING]")
+
+        lending_withdraw_test_config = {
+            'amount': {'from': 0.001, 'to': 0.001},
+            'action': 'WITHDRAW',
+            'lending_apps': ['ERALEND'],
+            'withdraw_sleep_interval': withdraw_interval
+        }
+
+        lending = Lending(zksync_min_native_balance, AccountStorage(), 1)
+
+        with self.assertRaises(EmptyDepositException):
+            lending.execute(*lending.parse_params(lending_withdraw_test_config), local_evm_test_account)
+
+    def test_shouldDepositAndWithdrawAll_balance(self, apps=['ERALEND', 'REACTORFUSION_LANDING', 'BASILISK_LANDING']):
+        logger.info("Test module [LENDING]")
+
+        for app in apps:
+            lending_deposit_test_config = {
+                'amount': 'all_balance',
+                'action': 'DEPOSIT',
+                'lending_apps': [app],
+                'withdraw_sleep_interval': withdraw_interval
+            }
+            lending_withdraw_test_config = {
+                'amount': 'all_balance',
+                'action': 'WITHDRAW',
+                'lending_apps': [app],
+                'withdraw_sleep_interval': withdraw_interval
+            }
+
+            lending = Lending(zksync_min_native_balance, AccountStorage(), 1)
+            lending.execute(*lending.parse_params(lending_deposit_test_config), local_evm_test_account)
+            lending.execute(*lending.parse_params(lending_withdraw_test_config), local_evm_test_account)
+
+    def test_shouldDeposit_WithdrawAll_balance(self, apps=['ERALEND', 'REACTORFUSION_LANDING', 'BASILISK_LANDING']):
+        logger.info("Test module [LENDING]")
+
+        for app in apps:
+            lending_deposit_test_config = {
+                'amount': 'all_balance',
+                'action': 'DEPOSIT+WITHDRAW',
+                'lending_apps': [app],
+                'withdraw_sleep_interval': {'from': 0, 'to': 0}
+            }
+
+            lending = Lending(zksync_min_native_balance, AccountStorage(), 1)
+            lending.execute(*lending.parse_params(lending_deposit_test_config), local_evm_test_account)

tests/core/modules/test_nft.py

@@ -0,0 +1,32 @@
+import unittest
+
+from loguru import logger
+
+from web3_wizzard_lib.core.modules.nft.era_domain import EraDomain
+from web3_wizzard_lib.core.modules.nft.zks_domain import ZksDomain
+from tests.core.modules.__init__ import init_set_test_config, \
+    local_evm_test_account
+
+
+class NftTest(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldTestEraDomain(self):
+        logger.info("Test module [ERA_DOMAIN, 8]")
+
+        try:
+            era_domain = EraDomain()
+
+            era_domain.execute(local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldTestZKSDomain(self):
+        logger.info("Test module [ZKSDomain, 9]")
+
+        try:
+            zks_domain = ZksDomain()
+
+            zks_domain.execute(local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")

tests/core/modules/test_nft_minter.py

@@ -0,0 +1,30 @@
+import unittest
+
+from loguru import logger
+from sybil_engine.config.app_config import set_network
+from sybil_engine.domain.account_storage import AccountStorage
+
+from web3_wizzard_lib.core.modules import NFTMinter
+from tests.core.modules.__init__ import zksync_test_account, zksync_min_native_balance, init_set_test_config
+
+nft_minter_test_config = {
+    'nft_amount_interval': {'from': 7, 'to': 7},
+    'nft_modules': ["TAVAERA", "ZKS_DOMAIN", "ERA_DOMAIN", "EMPTY_NFT", "OMNI_SEA", "MERKLY_MINTER", "KREATOR_LAND"],
+    'sleep_interval': {'from': 0, 'to': 0}
+}
+
+
+class TestRandomNFTModule(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldMintRandomNFT(self):
+        logger.info("Test module [NFT_MINTER, 15]")
+
+        set_network('LOCAL')
+
+        try:
+            nft_minter = NFTMinter(zksync_min_native_balance, AccountStorage(), range(4))
+
+            nft_minter.execute(*nft_minter.parse_params(nft_minter_test_config), zksync_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")

tests/core/modules/test_orbiter.py

@@ -0,0 +1,28 @@
+import unittest
+
+from loguru import logger
+
+from web3_wizzard_lib.core.modules.orbiter import OrbiterModule
+from tests.core.modules.__init__ import zksync_min_native_balance, init_set_test_config, \
+    local_evm_test_account
+
+orbiter_params = {
+    'bridge_amount_interval': {'from': 0.1, 'to': 1},
+    'from_chain': 'ZKSYNC',
+    'to_chain': 'ARBITRUM',
+}
+
+
+class TestOrbiterModule(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldBridge(self):
+        logger.info("Test module [ORBITER, 7]")
+
+        try:
+            orbiter = OrbiterModule(zksync_min_native_balance, local_evm_test_account)
+
+            orbiter.execute(*orbiter.parse_params(orbiter_params), local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+

tests/core/modules/test_sellall.py

@@ -0,0 +1,27 @@
+import unittest
+
+from loguru import logger
+
+from web3_wizzard_lib.core.modules import SellAll
+from tests.core.modules.__init__ import zksync_test_account, zksync_min_native_balance, init_set_test_config
+
+
+class TestSetAllModule(unittest.TestCase):
+
+    def test_shouldSellAllzkSync(self, chain='ZKSYNC', account=zksync_test_account):
+        sell_all_test_config = {
+            'chain': chain,
+            'receive_token': 'ETH',  # [USDC, ETH]
+            'sleep_interval': {'from': 0, 'to': 0}  # Interval between selling different tokens of 1 account
+        }
+
+        logger.info("Test module [SELL_ALL, 2]")
+
+        init_set_test_config()
+
+        try:
+            sell_all = SellAll(zksync_min_native_balance, account)
+
+            sell_all.execute(*sell_all.parse_params(sell_all_test_config), account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")

tests/core/modules/test_send_to_cex.py

@@ -0,0 +1,27 @@
+import unittest
+
+from loguru import logger
+
+from web3_wizzard_lib.core.modules import SendToCex
+from tests.core.modules.__init__ import zksync_min_native_balance, init_set_test_config, \
+    local_evm_test_account
+
+send_to_cex_test_config = {
+    'chain': 'ZKSYNC',
+    'amount': {'from': 1, 'to': 1},
+    'token': 'NATIVE'
+}
+
+
+class TestSendToCexModule(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldSendToCex(self):
+        logger.info("Test module [SEND_TO_CEX, 6]")
+
+        try:
+            send_to_cex = SendToCex(zksync_min_native_balance, local_evm_test_account)
+
+            send_to_cex.execute(*send_to_cex.parse_params(send_to_cex_test_config), local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")

tests/core/modules/test_stargate_auto_bridge.py

@@ -0,0 +1,32 @@
+import unittest
+
+from loguru import logger
+from sybil_engine.domain.account_storage import AccountStorage
+
+from web3_wizzard_lib.core.modules.stargate.auto_bridge import StargateAutoBridge
+from tests.core.modules.__init__ import init_set_test_config, \
+    test_account, test_min_native_balance
+
+stargate_auto_bridge_test_config = {
+    'bridge_amount_interval': {'from': 1, 'to': 1},
+    'bridge_token': 'ETH',
+    'end_network': '',  # name of network where all tokens will be collected
+    'retry_interval': {'from': 0, 'to': 0},
+    'sleep_interval': {'from': 0, 'to': 0},
+    'only_end_network_bridge': False,  # if True, then only bridge will be to END NETWORK
+    'original_chain_sequence': ['ARBITRUM', 'LINEA', 'BASE']
+}
+
+
+class TestStargateAutoBridge(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldMakeAutoBridge(self, account=test_account):
+        logger.info("Test module [STARGATE_AUTO_BRIDGE, 13]")
+
+        try:
+            stargate_auto_bridge = StargateAutoBridge(test_min_native_balance, AccountStorage())
+
+            stargate_auto_bridge.execute(*stargate_auto_bridge.parse_params(stargate_auto_bridge_test_config), account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")

tests/core/modules/test_stargate_bridge.py

@@ -0,0 +1,25 @@
+import unittest
+
+from loguru import logger
+
+from web3_wizzard_lib.core.modules.stargate.classic_bridge import StargateBridgeModule
+from tests.core.modules.__init__ import init_set_test_config, test_min_native_balance, \
+    local_evm_test_account
+
+stargate_classic_test_config = {
+    'from_chain': 'LINEA',
+    'to_chain': 'BASE',
+    'bridge_amount_interval': {'from': 1, 'to': 1},
+    'bridge_token': 'ETH',
+    'retry_interval': {'from': 60 * 25, 'to': 60 * 40}
+}
+
+
+class TestStargateBridgeModule(unittest.TestCase):
+    def test_bridgeStargate(self, account=local_evm_test_account):
+        logger.info("Test module [STARGATE_BRIDGE, 12]")
+
+        init_set_test_config()
+
+        stargate_bridge = StargateBridgeModule(test_min_native_balance, account)
+        stargate_bridge.execute(*stargate_bridge.parse_params(stargate_classic_test_config), account)