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

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']
+
+    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)

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

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

web3_wizzard_lib/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("web3_wizzard_lib.core.modules.swap")
+    return get_all_subclasses(Dex)
+
+swap_facade = SwapFacade(get_swap_classes())

web3_wizzard_lib/core/modules/swap/swap_list.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("web3_wizzard_lib.core.modules.swap")
+    return get_all_subclasses(Dex)
+
+swap_facade = SwapFacade(get_swap_classes())

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

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

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

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

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