web3-wizzard-lib 1.6.12__py3-none-any.whl → 1.6.15__py3-none-any.whl

web3_wizzard_lib/core/modules/stargate/classic_bridge.py

@@ -0,0 +1,34 @@
+from sybil_engine.module.module import Module, Order
+
+from web3_wizzard_lib.core.modules.stargate.bridge import StargateBridge
+
+
+class StargateBridgeModule(Module):
+    module_name = 'STARGATE_CLASSIC_BRIDGE'
+    module_config = 'stargate_classic_config'
+    random_order = Order.STRICT
+
+    def execute(self, bridge_amount_interval, bridge_token, retry_interval, from_chain, to_chain, account):
+        StargateBridge(retry_interval).bridge(
+            self.min_native_balance,
+            account,
+            bridge_amount_interval,
+            bridge_token,
+            from_chain,
+            to_chain
+        )
+
+    def log(self):
+        return "STARGATE CLASSIC"
+
+    def parse_params(self, module_params):
+        if 'retry_interval' not in module_params:
+            module_params['retry_interval'] = {'from': 60 * 5, 'to': 60 * 10}
+
+        return (
+            module_params['bridge_amount_interval'],
+            module_params['bridge_token'],
+            module_params['retry_interval'],
+            module_params['from_chain'],
+            module_params['to_chain']
+        )

web3_wizzard_lib/core/modules/stargate/farming.py

@@ -0,0 +1,163 @@
+from loguru import logger
+from sybil_engine.config.app_config import get_network
+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 Erc20Balance, NativeBalance
+from sybil_engine.domain.balance.balance_utils import get_native_balance, interval_to_eth_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.module.module import Module
+from sybil_engine.utils.utils import randomized_sleeping
+from sybil_engine.utils.web3_utils import init_web3, get_amount_to_bridge_usdc, get_max_balance_data
+
+from web3_wizzard_lib.core.contract.stargate_farming import StargateFarming
+from web3_wizzard_lib.core.contract.stargate_router import StargateRouter
+from web3_wizzard_lib.core.modules.stargate.pool import add_to_pool, find_max_pool_chain, get_pool_token_name, get_pool_balances
+from web3_wizzard_lib.core.modules.stargate.stargate_balance_utils import StargatePoolToken
+
+all_chains = {
+    'MAIN': {
+        'USDC': ['ARBITRUM', 'BASE', 'BSC', 'POLYGON', 'AVALANCHE', 'OPTIMISM', 'FANTOM'],
+        'ETH': ['ARBITRUM', 'BASE', 'LINEA', 'OPTIMISM']
+    },
+    'LOCAL': {
+        'USDC': ['BASE'],
+        'ETH': ['BASE']
+    },
+    'GOERLI': {
+        'USDC': ['LINEA', 'BASE'],
+        'ETH': ['LINEA', 'BASE']
+    }
+}
+
+
+class StargateFarmingModule(Module):
+    module_name = 'STARGATE_FARMING'
+    module_config = 'stargate_farming_config'
+
+    def execute(self, bridge_amount_interval, chain, operation, all_balance_mode, token, operation_sleep_interval,
+                account):
+        try:
+            logger.info(f"=============== Stargate staking: {account.address} ===============")
+
+            chains = all_chains[get_network()][token]
+
+            if 'ADD_TO_POOL' in operation:
+                self.add_to_pool_logic(account, all_balance_mode, bridge_amount_interval, chain, chains, token)
+                randomized_sleeping(operation_sleep_interval)
+
+            if 'DEPOSIT' in operation:
+                self.deposit_logic(account, chains, token)
+                randomized_sleeping(operation_sleep_interval)
+
+            if 'WITHDRAW' in operation:
+                self.withdraw_logic(account, chains, token)
+                randomized_sleeping(operation_sleep_interval)
+
+            if 'REDEEM_FROM_POOL' in operation:
+                self.redeem_from_pool_logic(account, chains, token)
+                randomized_sleeping(operation_sleep_interval)
+        except Exception as e:
+            logger.info(f"Error during farming: {e}")
+
+    def redeem_from_pool_logic(self, account, chains, token):
+        pool_balances = get_pool_balances(token, account, chains)
+        chain, pool_balance, web3 = find_max_pool_chain(pool_balances)
+        chain_instance = get_chain_instance(chain)
+        stargate_router = StargateRouter(get_contracts_for_chain(chain)["STARGATE_ROUTER"], web3)
+        logger.info(f"Redeem from {chain} pool {pool_balance}")
+        if token == 'USDC':
+            stargate_pool_id = chain_instance['stargate_usdc_pool']
+        else:
+            stargate_pool_id = chain_instance['stargate_eth_pool']
+        if pool_balance.wei > 0:
+            stargate_router.instant_redeem(account, pool_balance.wei, stargate_pool_id)
+        else:
+            logger.info(f"Pool is empty, ignoring")
+
+    def withdraw_logic(self, account, chains, token):
+        logger.info("Withdraw from farming")
+        farm_balances = self.get_farm_balances(account, token, chains)
+        chain, farm_balance, web3 = find_max_pool_chain(farm_balances)
+        farming_address = get_contracts_for_chain(chain)['STARGATE_FARMING']
+        stargate_farming = StargateFarming(farming_address, web3)
+        logger.info(f"Balance in farming {farm_balance}, withdrawing all")
+        if farm_balance.wei > 0:
+            stargate_farming.withdraw(account, farm_balance.wei)
+        else:
+            logger.info(f"Farming balance is empty, ignoring")
+
+    def deposit_logic(self, account, chains, token):
+        logger.info("Deposit to farm")
+
+        pool_balances = get_pool_balances(token, account, chains)
+        chain, pool_balance, web3 = find_max_pool_chain(pool_balances)
+
+        chain_instance = get_chain_instance(chain)
+        farming_address = get_contracts_for_chain(chain)['STARGATE_FARMING']
+
+        stargate_farming = StargateFarming(farming_address, web3)
+        logger.info(f"Amount in {chain} pool {pool_balance}")
+
+        pool_token_name = get_pool_token_name(token)
+        stargate_pool_token = StargatePoolToken(chain, pool_token_name, web3)
+
+        if stargate_pool_token.allowance(account, farming_address) < pool_balance.wei:
+            stargate_pool_token.approve(account, farming_address)
+
+        stargate_farming.deposit(account, pool_balance)
+
+    def add_to_pool_logic(self, account, all_balance_mode, bridge_amount_interval, chain, chains, token):
+
+        def get_balance_to_pool(token_type, chain_instance, web3):
+            if token_type == 'USDC':
+                stargate_token = Erc20Token(chain, 'USDC', web3)
+                return stargate_token.balance(account)
+            else:
+                return get_native_balance(account, web3, chain_instance)
+
+        if bridge_amount_interval == 'all_balance':
+            if all_balance_mode == 0:
+                max_balance_chain, amount_to_pool, native_balance, web3 = get_max_balance_data(token, chains, account)
+                chain_instance = get_chain_instance(max_balance_chain)
+                amount_to_pool = native_balance
+            else:
+                chain_instance = get_chain_instance(chain)
+                web3 = init_web3(chain_instance, account.proxy)
+                amount_to_pool = get_balance_to_pool(token, chain_instance, web3)
+            amount_to_pool = amount_to_pool.minus(self.min_native_balance)
+        else:
+            chain_instance = get_chain_instance(chain)
+            web3 = init_web3(chain_instance, account.proxy)
+            amount_to_pool = get_amount_to_bridge_usdc(
+                bridge_amount_interval) if token == 'USDC' else interval_to_eth_balance(bridge_amount_interval, account,
+                                                                                        chain_instance['chain'], web3)
+
+        logger.info(f"Adding to stargate {chain_instance['chain']} pool")
+        add_to_pool(account, amount_to_pool, token, chain_instance, web3)
+
+    def get_farm_balances(self, account, token, chains):
+
+        def get_balance_for_chain(chain):
+            web3 = init_web3(get_chain_instance(chain), account.proxy)
+            farming_address = get_contracts_for_chain(chain)['STARGATE_FARMING']
+            farming = StargateFarming(farming_address, web3)
+
+            if token == 'USDC':
+                return chain, Erc20Balance(farming.user_info(account), chain, token), web3
+            else:
+                return chain, NativeBalance(farming.user_info(account), chain, token), web3
+
+        return [get_balance_for_chain(chain) for chain in chains]
+
+    def log(self):
+        return "STARGATE FARMING"
+
+    def parse_params(self, module_params):
+        return (
+            module_params['bridge_amount_interval'],
+            module_params['chain'],
+            module_params['operation'],
+            module_params['all_balance_mode'],
+            module_params['token'],
+            module_params['operation_sleep_interval']
+        )

web3_wizzard_lib/core/modules/stargate/l0_data.py

@@ -0,0 +1,10 @@
+l0_chain_ids = {
+    'ARBITRUM': 110,
+    'OPTIMISM': 111,
+    'ZKSYNC': 165,
+    'ARBITRUM_NOVA': 175,
+    'LINEA': 183,
+    'BASE': 184,
+    'SCROLL': 214,
+    'POLYGON': 109
+}

web3_wizzard_lib/core/modules/stargate/pool.py

@@ -0,0 +1,74 @@
+from loguru import logger
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance_utils import get_native_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.utils.utils import ModuleException
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.stargate_router import StargateRouter
+from web3_wizzard_lib.core.contract.stargate_router_eth import StargateRouterEth
+from web3_wizzard_lib.core.modules.stargate.stargate_balance_utils import StargatePoolToken
+
+
+def add_to_pool(account, amount_to_pool, bridge_token, chain_instance, web3):
+    def get_router_details(token_type, chain_inst):
+        contracts = get_contracts_for_chain(chain_inst['chain'])
+        if token_type == 'ETH':
+            return StargateRouterEth(contracts["STARGATE_ROUTER_ETH"], web3), None
+        else:
+            erc20 = Erc20Token(chain_inst['chain'], token_type, web3)
+
+            if erc20.allowance(account, contracts["STARGATE_ROUTER"]) < erc20.balance(account).wei:
+                erc20.approve(account, contracts["STARGATE_ROUTER"])
+            return StargateRouter(contracts["STARGATE_ROUTER"], web3), erc20
+
+    logger.info(f"======= Adding liquidity {bridge_token} {chain_instance['chain']} ::: {account.address} =======")
+
+    native_balance = get_native_balance(account, web3, chain_instance)
+    logger.info(f"Native balance: {native_balance}")
+
+    stargate_router, erc20 = get_router_details(bridge_token, chain_instance)
+
+    balance = native_balance if bridge_token == 'ETH' else erc20.balance(account)
+    if bridge_token != 'ETH':
+        logger.info(f"Balance: {balance}")
+
+    verify_balance(amount_to_pool, balance, native_balance)
+
+    func = stargate_router.add_liquidity_eth if bridge_token == 'ETH' else stargate_router.add_liquidity
+
+    logger.info(f"Pooling: {amount_to_pool}")
+    func(account, amount_to_pool)
+
+
+def verify_balance(amount_to_pool, balance, erc20_token):
+    if amount_to_pool.wei > balance.wei:
+        raise Exception(f"Account balance ({amount_to_pool}) is lower than amount to pool.")
+
+    if balance.wei == 0:
+        logger.info(f"{erc20_token.token} balance is 0")
+        raise ModuleException("")
+
+
+def find_max_pool_chain(balances):
+    max_usdc_balance = max(balances, key=lambda x: x[1].wei)
+
+    if max_usdc_balance[1] == 0:
+        raise Exception("Can't bridge tokens, all chain USDC balances are zero")
+
+    return max_usdc_balance
+
+
+def get_pool_token_name(token_type):
+    return 'STARGATE_ETH_POOL' if token_type == 'ETH' else 'STARGATE_USDT_POOL'
+
+
+def get_pool_balances(token, account, chains):
+    return [get_pool_balance_for_chain(chain, token, account) for chain in chains]
+
+
+def get_pool_balance_for_chain(chain, pool_token_name, account):
+    web3 = init_web3(get_chain_instance(chain), account.proxy)
+    pool_token_instance = StargatePoolToken(chain, get_pool_token_name(pool_token_name), web3)
+    return chain, pool_token_instance.balance(account), web3

web3_wizzard_lib/core/modules/stargate/stargate_balance_utils.py

@@ -0,0 +1,25 @@
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.domain.balance.balance import Erc20Balance, NativeBalance
+
+from web3_wizzard_lib.core.contract.stargate_token_pool import StargateTokenPool
+
+
+class StargatePoolToken:
+    def __init__(self, chain, token, web3):
+        self.chain = chain
+        self.token = token
+        self.web3 = web3
+        self.token_pool_contract = StargateTokenPool(get_tokens_for_chain(self.chain)[self.token], self.web3)
+
+    def balance(self, account):
+        if self.token == 'STARGATE_USDC_POOL':
+            return Erc20Balance(self.token_pool_contract.balance_of(account), self.chain, self.token)
+        else:
+            return NativeBalance(self.token_pool_contract.balance_of(account), self.chain, self.token)
+
+    def approve(self, account, contract_on_approve):
+        return self.token_pool_contract.approve(account, contract_on_approve)
+
+    def allowance(self, account, allowance_contract):
+        return self.token_pool_contract.allowance(account, allowance_contract)
+

web3_wizzard_lib/core/modules/stargate/stargate_gas_checker.py

@@ -0,0 +1,68 @@
+import functools
+
+from loguru import logger
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.domain.balance.balance import NativeBalance, NotEnoughNativeBalance
+from sybil_engine.domain.balance.balance_utils import get_native_balance, from_eth_to_wei
+from sybil_engine.utils.l0_utils import L0FeeToHigh
+from sybil_engine.utils.utils import randomized_sleeping
+
+
+def stargate_check_gas(token):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(self, *args):
+            check_gas(token, self.chain_instance, args[-1], args[0], self.web3)
+            return func(self, *args)
+
+        return wrapper
+
+    return decorator
+
+
+def check_gas(token, chain_instance, to_chain_instance, account, web3):
+    while True:
+        try:
+            verify_stargate_fee(token, chain_instance, to_chain_instance, account, web3)
+            return
+        except L0FeeToHigh as e:
+            logger.info(e)
+            randomized_sleeping({'from': 60 * 4, 'to': 60 * 8})
+        except Exception as e:
+            raise StargateBridgeException("Stargate bridge error") from e
+
+
+def verify_stargate_fee(token, from_chain_instance, to_chain_instance, account, web3):
+    native_balance = get_native_balance(account, web3, from_chain_instance)
+    native_fee_balance = get_native_fee_balance(token, native_balance, from_chain_instance, to_chain_instance, account,
+                                                web3)
+
+    logger.info(f"Native LayerZero fee: {native_fee_balance.log_line()}")
+    if native_fee_balance.wei > native_balance.wei:
+        raise NotEnoughNativeBalance(
+            f"Native balance ({native_balance.log_line()}) < Native LayerZero required fee")
+    if native_fee_balance.wei > from_eth_to_wei(from_chain_instance['max_l0_fee']):
+        raise L0FeeToHigh(f"Native LayerZero fee is to high")
+
+
+def get_native_fee_balance(token, native_balance, from_chain_instance, to_chain_instance, account, web3):
+    chain_contracts = get_contracts_for_chain(from_chain_instance['chain'])
+
+    if token in ['ETH', 'USDC']:
+        from web3_wizzard_lib.core.contract.stargate_router import StargateRouter
+        stargate_router = StargateRouter(chain_contracts["STARGATE_ROUTER"], web3)
+
+        wei_balance = stargate_router.count_native_fee_stargate(
+            to_chain_instance['stargate_chain_id'],
+            account.address
+        )
+    else:
+        raise Exception("Token not supported")
+
+    return NativeBalance(wei_balance, native_balance.chain, native_balance.token)
+
+
+class StargateBridgeException(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)

web3_wizzard_lib/core/modules/swap/__init__.py

@@ -0,0 +1 @@
+

web3_wizzard_lib/core/modules/swap/horizondex.py

@@ -0,0 +1,38 @@
+from sybil_engine.domain.dex import Dex
+
+from web3_wizzard_lib.core.contract.horizondex_router import HorizonDexRouter
+from ...contract.horizondex_quoter import HorizonDexQuoter
+
+
+class Horizondex(Dex):
+    dex_name = 'horizondex'
+    swap_contract = 'HORIZONDEX'
+    supported_chains = ['BASE', 'LINEA']
+
+    def __init__(self, chain_instance, web3):
+        super().__init__(chain_instance, web3)
+        self.weth_address = self.tokens['WETH']
+        self.horizondex_router = HorizonDexRouter(self.chain_contracts[self.swap_contract], self.web3)
+
+    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, amount_out_min, from_token_address, self.weth_address]
+        func = self.horizondex_router.multicall
+
+        return args, func
+
+    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, amount_out_min, self.weth_address, to_token_address]
+        func = self.horizondex_router.swap_exact_input_single
+
+        return args, func
+
+    def swap_token_for_token(self, account, amount_to_swap, slippage, from_token_address, to_token_address):
+        raise Exception("Not supported yet")
+
+    def get_amount_out_min(self, amount_to_swap, from_token_address, to_token_address):
+        horizondex_quoter_contract = self.chain_contracts["HORIZONDEX_QUOTER"]
+        horizondex_quoter = HorizonDexQuoter(horizondex_quoter_contract, self.web3)
+
+        return horizondex_quoter.quote_exact_input_single(amount_to_swap.wei, from_token_address, to_token_address)

web3_wizzard_lib/core/modules/swap/izumi.py

@@ -0,0 +1,41 @@
+from sybil_engine.domain.dex import Dex
+
+from ...contract.izumi import IzumiRouter
+
+
+class Izumi(Dex):
+    dex_name = 'izumi'
+    swap_contract = 'IZUMI'
+    supported_chains = ['LINEA']
+
+    def __init__(self, chain_instance, web3):
+        super().__init__(chain_instance, web3)
+        self.weth_address = self.tokens['WETH']
+        self.izumi = IzumiRouter(self.chain_contracts[self.swap_contract], self.web3)
+
+    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, amount_out_min, from_token_address, self.weth_address]
+        func = self.izumi.multicall
+
+        return args, func
+
+    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, amount_out_min, self.weth_address, to_token_address]
+        func = self.izumi.multicall
+
+        return args, func
+
+    def swap_token_for_token(self, account, amount_to_swap, slippage, from_token_address, to_token_address):
+        raise Exception("Not supported yet")
+
+    def get_amount_out_min(self, amount_to_swap, from_token_address, to_token_address):
+        izumi = self.chain_contracts["IZUMI"]
+        izumi_router = IzumiRouter(izumi, self.web3)
+
+        if amount_to_swap.token == 'ETH':
+            return int((izumi_router.quote_price('weETH') * amount_to_swap.wei) * 0.999)
+        else:
+            return int((izumi_router.quote_price('ETH') * amount_to_swap.wei) * 0.999)
+

web3_wizzard_lib/core/modules/swap/lineaswap.py

@@ -0,0 +1,34 @@
+from sybil_engine.domain.dex import Dex
+
+from web3_wizzard_lib.core.contract.lineaswaprouter import LineaSwapRouter
+
+
+class LineaSwap(Dex):
+    dex_name = 'lineaswap'
+    swap_contract = "LINEASWAP"
+    supported_chains = ['BASE', 'LINEA']
+
+    def __init__(self, chain_instance, web3):
+        super().__init__(chain_instance, web3)
+        self.linea_swap_router = LineaSwapRouter(self.chain_contracts[self.swap_contract], self.web3)
+        self.weth_address = self.tokens['WETH']
+
+    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.linea_swap_router.swap_exact_eth_for_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.linea_swap_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):
+        raise Exception("Not supported")
+
+    def get_amount_out_min(self, amount_to_swap, from_token_address, to_token_address):
+        return self.linea_swap_router.get_amount_out(amount_to_swap, from_token_address, to_token_address)

web3_wizzard_lib/core/modules/swap/maverick.py

@@ -0,0 +1,66 @@
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.domain.dex import Dex
+
+from web3_wizzard_lib.core.contract.maverick_multicall import MaverickMulticall
+from ...contract.pancake_pool import PancakePool
+from ...contract.pancake_quoter import PancakeQuoter
+
+pool_addresses = {
+    'ZKSYNC': {
+        "ETH>USDC": "0x41c8cf74c27554a8972d3bf3d2bd4a14d8b604ab"
+    },
+    'BASE': {
+        "ETH>USDbC": "0x06e6736ca9e922766279a22b75a600fe8b8473b6",
+        "ETH>USDC": "0x06e6736ca9e922766279a22b75a600fe8b8473b6"
+    }
+}
+
+
+class Maverick(Dex):
+    dex_name = 'maverick'
+    swap_contract = 'MAV_ROUTER'
+    supported_chains = ['ZKSYNC', 'BASE']
+
+    def __init__(self, chain_instance, web3):
+        self.chain_instance = chain_instance
+        super().__init__(chain_instance, web3)
+        self.weth_contract = self.tokens['WETH']
+        self.pancake_pool = PancakePool(self.chain_contracts["PANCAKE_FACTORY"], self.web3)
+        self.maverick_router = MaverickMulticall(self.chain_contracts[self.swap_contract], self.web3)
+
+    def swap_native_for_token(self, account, amount_to_swap, slippage, to_token_address):
+        erc20_token = Erc20Token(self.chain_instance['chain'], to_token_address, self.web3)
+        pair_name = f"{self.chain_instance['gas_token']}>{erc20_token.symbol()}"
+        maverick_pool_address = pool_addresses[self.chain_instance['chain']][pair_name]
+
+        pool = self.pancake_pool.get_pool(self.weth_contract, to_token_address)
+
+        if pool == self.tokens['ZERO_ADDRESS']:
+            raise Exception(f"[{account.address}] Swap path {self.weth_contract} to {to_token_address} not found!")
+
+        amount_out = int(self.get_amount_out_min(amount_to_swap, self.weth_contract, to_token_address) * slippage)
+
+        args = [account, amount_to_swap, amount_out, self.weth_contract, maverick_pool_address, to_token_address]
+
+        return args, self.maverick_router.multicall
+
+    def swap_token_for_native(self, account, amount_to_swap, from_token_address, slippage):
+        pair_name = f'{self.chain_instance["gas_token"]}>{amount_to_swap.token}'
+        maverick_pool_address = pool_addresses[self.chain_instance['chain']][pair_name]
+
+        pool = self.pancake_pool.get_pool(from_token_address, self.weth_contract)
+
+        if pool == self.tokens['ZERO_ADDRESS']:
+            raise Exception(f"[{account.address}] Swap path {from_token_address} to {self.weth_contract} not found!")
+
+        amount_out = int(self.get_amount_out_min(amount_to_swap, from_token_address, self.weth_contract) * slippage)
+
+        args = [account, amount_to_swap, amount_out, from_token_address, maverick_pool_address, self.weth_contract]
+
+        return args, self.maverick_router.multicall
+
+    def get_amount_out_min(self, amount_to_swap, token_in_address, token_out_address):
+        pancake_quoter_contract = self.chain_contracts["PANCAKE_QUOTER"]
+        pancake_quoter = PancakeQuoter(pancake_quoter_contract, self.web3)
+
+        return pancake_quoter.quote_exact_input_single(token_in_address, token_out_address, amount_to_swap.wei)

web3_wizzard_lib/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)

web3_wizzard_lib/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', 'ARBITRUM']
+
+    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)