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

core/modules/stargate/bridge_eth.py

@@ -1,59 +0,0 @@
-from loguru import logger
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.domain.balance.balance import NotEnoughNativeBalance
-from sybil_engine.domain.balance.balance_utils import from_wei_to_eth, from_eth_to_wei
-from sybil_engine.utils.utils import interval_to_round
-
-from web3_wizzard_lib.core.contract.stargate_router_eth import StargateRouterEth
-from web3_wizzard_lib.core.modules.stargate.stargate_gas_checker import get_native_fee_balance
-
-
-def bridge_eth(native_without_min, account, bridge_amount_interval, from_chain_instance, to_chain_instance, web3):
-    contracts = get_contracts_for_chain(from_chain_instance['chain'])
-
-    native_fee = get_native_fee_balance(
-        'ETH',
-        native_without_min,
-        from_chain_instance,
-        to_chain_instance,
-        account,
-        web3
-    )
-
-    if native_fee.wei > native_without_min.wei:
-        raise NotEnoughNativeBalance(
-            f"Native balance ({native_without_min}) "
-            f"in {native_without_min.chain} is lower than required fee ({native_fee}",
-            from_chain_instance['chain']
-        )
-
-    if bridge_amount_interval == 'all_balance':
-        value_wei = native_without_min.wei
-
-        if value_wei < 0:
-            raise Exception('Not enough balance')
-
-        amount_to_bridge_wei = value_wei - native_fee.wei
-        amount_to_bridge_eth = from_wei_to_eth(amount_to_bridge_wei)
-    else:
-        amount_to_bridge_eth = interval_to_round(bridge_amount_interval)
-        amount_to_bridge_wei = from_eth_to_wei(amount_to_bridge_eth)
-
-        value_wei = amount_to_bridge_wei + native_fee.wei
-
-    value_wei = value_wei
-    value_eth = from_wei_to_eth(value_wei)
-
-    if value_wei > native_without_min.wei:
-        raise NotEnoughNativeBalance(
-            f"The account balance ({native_without_min}) < bridging amount ({value_eth}{native_without_min.token}).")
-
-    logger.info(f"Bridging: {amount_to_bridge_eth} {native_without_min.token}")
-    logger.info(f"Trying to bridge with value: {value_eth}{native_without_min.token}")
-
-    stargate_router_eth_address = contracts["STARGATE_ROUTER_ETH"]
-    stargate_router = StargateRouterEth(stargate_router_eth_address, web3)
-
-    args = [account, value_wei, amount_to_bridge_wei, to_chain_instance]
-
-    stargate_router.swap_eth(*args)

core/modules/stargate/bridge_tokens.py

@@ -1,48 +0,0 @@
-from loguru import logger
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.domain.balance.balance import Erc20Balance, NotEnoughNativeBalance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.utils.web3_utils import get_amount_to_bridge_usdc
-
-from web3_wizzard_lib.core.contract.stargate_router import StargateRouter
-
-
-def bridge_usdc(native_balance, account, bridge_amount_interval, from_chain_config, to_chain_config, web3):
-    if (from_chain_config['chain'] == 'FANTOM' and to_chain_config['chain'] == 'BASE') or (
-            to_chain_config['chain'] == 'FANTOM' and from_chain_config['chain'] == 'BASE'):
-        raise Exception('Stargate does not allow FANTOM<>BASE USDC transfer ')
-    erc20_token = Erc20Token(from_chain_config['chain'], 'USDC', web3)
-
-    token_balance = erc20_token.balance(account)
-
-    logger.info(f"Token balance: {token_balance}")
-
-    if token_balance.wei == 0:
-        raise Exception(f"USDC balance is 0")
-
-    amount_to_bridge = token_balance if bridge_amount_interval == 'all_balance' else Erc20Balance(
-        get_amount_to_bridge_usdc(bridge_amount_interval),
-        native_balance.chain,
-        'USDC'
-    )
-
-    if amount_to_bridge.wei > token_balance.wei:
-        raise NotEnoughNativeBalance(f"Account balance ({amount_to_bridge}) < {amount_to_bridge} amount to bridge.")
-
-    logger.info(f"Bridging: {amount_to_bridge}")
-
-    erc20_token = Erc20Token(from_chain_config['chain'], "USDC", web3)
-
-    chain_contracts = get_contracts_for_chain(from_chain_config['chain'])
-
-    stargate_router_address = chain_contracts["STARGATE_ROUTER"]
-
-    if erc20_token.allowance(account, stargate_router_address) < amount_to_bridge.wei:
-        erc20_token.allowance(account, stargate_router_address)
-
-    stargate_router = StargateRouter(chain_contracts["STARGATE_ROUTER"], web3)
-    native_fee_wei = stargate_router.count_native_fee_stargate(to_chain_config['stargate_chain_id'], account.address)
-
-    args = [account, native_fee_wei, amount_to_bridge, to_chain_config]
-
-    stargate_router.swap(*args)

core/modules/stargate/classic_bridge.py

@@ -1,34 +0,0 @@
-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']
-        )

core/modules/stargate/farming.py

@@ -1,163 +0,0 @@
-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 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']
-        )

core/modules/stargate/l0_data.py

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

core/modules/stargate/pool.py

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

core/modules/stargate/stargate_balance_utils.py

@@ -1,25 +0,0 @@
-from sybil_engine.data.tokens import get_tokens_for_chain
-from sybil_engine.domain.balance.balance import Erc20Balance, NativeBalance
-
-from web3_wizzard_lib.core 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)
-

core/modules/stargate/stargate_gas_checker.py

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

core/modules/swap/__init__.py

@@ -1 +0,0 @@
-

core/modules/swap/horizondex.py

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

core/modules/swap/izumi.py

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

core/modules/swap/lineaswap.py

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

core/modules/swap/maverick.py

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