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

web3_wizzard_lib/core/modules/swap/one_inch.py

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

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

@@ -1,11 +0,0 @@
-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
-
-import web3_wizzard_lib.core.modules.swap
-
-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

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

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

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

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

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

web3_wizzard_lib/core/modules/warm_up.py

@@ -1,98 +0,0 @@
-import random
-
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.data.pairs import Pairs
-from sybil_engine.domain.balance.balance_utils import verify_balance, amount_to_swap_from_interval
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.module.module import Order, RepeatableModule
-from sybil_engine.utils.utils import interval_to_int, randomized_sleeping, SwapException
-from sybil_engine.utils.validation_utils import validate_amount_interval_possible_empty, validate_token, \
-    validate_interval, validate_dex_list
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.modules.swap.swap_list import swap_facade
-
-
-class WarmUp(RepeatableModule):
-    module_name = 'WARMUP'
-    module_config = 'warmup_config'
-    allowed_chains = ['ZKSYNC', 'LINEA', 'BASE', 'SCROLL', 'ARBITRUM']
-    random_order = Order.RANDOM
-    repeat_conf = 'amount_of_warmups'
-
-    @RepeatableModule.repeatable_log
-    def execute(self, chain, swap_amount_interval, warm_token, amount_of_warmups, allowed_dex, pair_names: list,
-                sell_tokens, sleep_interval, account):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        swap_amount = interval_to_int(amount_of_warmups)
-
-        if len(pair_names) > 0:
-            logger.info(f"Warmup pairs {pair_names}")
-
-        pair = Pairs(swap_facade)
-
-        pair_swaps = pair.get_warmup_pair_swaps(allowed_dex, chain, pair_names, swap_amount, warm_token)
-        random.shuffle(pair_swaps)
-        self._warm_up(chain_instance, pair_swaps, sell_tokens, sleep_interval, swap_amount_interval, account, web3)
-
-    def _warm_up(self, chain_instance, pair_swaps, sell_tokens, sleep_interval, swap_amount_interval, account, web3):
-        pair, swaps = random.choice(pair_swaps)
-        random.shuffle(swaps)
-
-        native_balance = verify_balance(self.min_native_balance, chain_instance, account, web3)
-        buy_dex, sell_dex = swaps[0], swaps[-1]
-
-        self._warm_up_pair(buy_dex, sell_dex, native_balance, swap_amount_interval, chain_instance, pair, sell_tokens,
-                           sleep_interval, account, web3)
-
-        randomized_sleeping(sleep_interval)
-
-    def _warm_up_pair(self, buy_dex, sell_dex, native_balance, swap_amount_interval, chain_instance, pair, sell_tokens,
-                      sleep_interval, account, web3):
-        warm_up_token = pair['tokens'][0]
-        token = pair['tokens'][1]
-
-        amount_to_swap = amount_to_swap_from_interval(account, chain_instance['chain'], self.min_native_balance,
-                                                      native_balance, swap_amount_interval, warm_up_token, web3)
-        swap_facade.swap(account, amount_to_swap, chain_instance, pair, buy_dex, warm_up_token, token, web3)
-        randomized_sleeping(sleep_interval)
-
-        if sell_tokens:
-            try:
-                self.execute_sell(chain_instance, pair, sell_dex, account, web3)
-            except SwapException as e:
-                logger.error(e)
-                self.execute_sell(chain_instance, pair, buy_dex, account, web3)
-
-    def execute_sell(self, chain_instance, pair, sell_dex, account, web3):
-        amount_to_swap = Erc20Token(chain_instance['chain'], pair['tokens'][1], web3).balance(account)
-        swap_facade.swap(account, amount_to_swap, chain_instance, pair, sell_dex, amount_to_swap.token,
-                         pair['tokens'][0], web3)
-
-    def parse_params(self, module_params):
-        self.validate_supported_chain(module_params['chain'])
-        validate_amount_interval_possible_empty(module_params["swap_amount_interval"])
-        validate_token(module_params["token"])
-        validate_interval(module_params["amount_of_warmups"])
-        validate_dex_list(module_params["allowed_dex"])
-        validate_interval(module_params["pair_sleep_interval"])
-
-        return (
-            module_params["chain"],
-            module_params["swap_amount_interval"],
-            module_params["token"],
-            module_params["amount_of_warmups"],
-            module_params["allowed_dex"],
-            module_params["warmup_pairs"],
-            module_params["sell_tokens"],
-            module_params["pair_sleep_interval"]
-        )
-
-    def log(self):
-        return "WARM UP"
-
-    def sleep_after(self):
-        return False

web3_wizzard_lib/core/modules/wrapping.py

@@ -1,74 +0,0 @@
-from loguru import logger
-from sybil_engine.contract.weth import WETH
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.data.tokens import get_tokens_for_chain
-from sybil_engine.domain.balance.balance import NotEnoughNativeBalance
-from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance, verify_balance, interval_to_weth_balance
-from sybil_engine.module.module import Module
-from sybil_engine.utils.utils import ConfigurationException
-from sybil_engine.utils.validation_utils import validate_amount_interval
-from sybil_engine.utils.web3_utils import init_web3
-
-
-class Wrapping(Module):
-    module_name = 'WRAPPING'
-    module_config = 'wrap_config'
-    allowed_chains = ['ZKSYNC', 'LINEA', 'BASE', 'SCROLL', 'ARBITRUM']
-    sleep_after_var = True
-
-    def execute(self, wrapping_chain, swap_amount_interval, action, account):
-        self.sleep_after_var = True
-        chain_instance = get_chain_instance(wrapping_chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        weth_contract = get_tokens_for_chain(chain_instance['chain'])['WETH']
-        weth = WETH(weth_contract, web3)
-
-        if action == 'WRAP':
-            amount_to_wrap = interval_to_eth_balance(swap_amount_interval, account, chain_instance['chain'], web3)
-
-            logger.info(f"{action} {str(amount_to_wrap)}")
-
-            native_balance = verify_balance(self.min_native_balance, chain_instance, account, web3)
-
-            if swap_amount_interval == 'all_balance':
-                amount_to_wrap = amount_to_wrap.minus(self.min_native_balance)
-
-            if amount_to_wrap.wei > native_balance.wei:
-                raise NotEnoughNativeBalance(
-                    f"Account balance {native_balance} < {amount_to_wrap} amount to wrap.")
-
-            weth.deposit(account, amount_to_wrap)
-        elif action == 'UNWRAP':
-            if swap_amount_interval == '':
-                swap_amount_interval = 'all_balance'
-
-            amount_to_unwrap = interval_to_weth_balance(
-                swap_amount_interval,
-                account,
-                chain_instance['chain'],
-                web3
-            )
-
-            if amount_to_unwrap.wei < 1000:
-                logger.info(f"WETH balance is {amount_to_unwrap}, skip unwrapping")
-                self.sleep_after_var = False
-                return
-
-            logger.info(f"{action} {amount_to_unwrap}")
-
-            weth.withdraw(account, amount_to_unwrap)
-        else:
-            raise ConfigurationException(f'Wrong Action {action}')
-
-    def parse_params(self, module_params):
-        self.validate_supported_chain(module_params['chain'])
-        validate_amount_interval(module_params['amount_interval'])
-
-        return module_params['chain'], module_params['amount_interval'], module_params['action']
-
-    def log(self):
-        return "WRAPPING"
-
-    def sleep_after(self):
-        return self.sleep_after_var

web3_wizzard_lib/core/modules/zkdx.py

@@ -1,63 +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 interval_to_erc20_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.module.module import Module
-from sybil_engine.utils.app_account_utils import AppAccount
-from sybil_engine.utils.utils import AccountException
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.zkdx_contract import ZKDXContract
-from web3_wizzard_lib.core.contract.zkdx_data import ZKDXDataContract
-
-
-class ZKDX(Module):
-    module_name = 'ZKDX'
-    module_config = 'zkdx_config'
-
-    def execute(self, action, amount_interval, account: AppAccount, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        zkdx_contract = get_contracts_for_chain(chain)['ZKDX']
-        zkdx_data_contract = get_contracts_for_chain(chain)['ZKDX_DATA']
-
-        zkdx = ZKDXContract(zkdx_contract, web3)
-
-        if action == 'DEPOSIT':
-            amount = interval_to_erc20_balance(amount_interval, account, 'USDC', chain, web3)
-
-            erc20 = Erc20Token(chain, 'USDC', web3)
-
-            if erc20.allowance(account, zkdx_contract) < erc20.balance(account).wei:
-                erc20.approve(account, zkdx_contract)
-
-            logger.info(f"Deposit {amount} to ZKDX")
-            zkdx.swap_to_zkdx(account, amount)
-        if action == 'WITHDRAW':
-            zkdx_data = ZKDXDataContract(zkdx_data_contract, web3)
-            balance = zkdx_data.get_balance(account)[0]
-
-            if balance == 0:
-                raise AccountException("ZKDX Balance is 0, skip")
-
-            logger.info(f"WITHDRAW {balance / 10 ** 18} ZUSD to ZKDX")
-            zkdx.swap_from_zkdx(account, balance)
-        else:
-            raise Exception(f"{action} action not supported")
-
-    def log(self):
-        return "ZKDX"
-
-    def parse_params(self, module_params):
-        return [
-            module_params['action'],
-            module_params['amount_interval']
-        ]
-
-
-class EmptyDepositException(Exception):
-    def __init__(self, message):
-        self.message = message
-        super().__init__(self.message)

web3_wizzard_lib/core/utils/ai_utils.py

@@ -1,45 +0,0 @@
-import requests
-
-from web3_wizzard_lib.core.utils.benchmark_utils import benchmark
-
-
-class AIChat:
-    def ask(self, question):
-        pass
-
-
-class ChatGPT:
-    def __init__(self, token):
-        self.token = token
-
-    @benchmark
-    def ask(self, question):
-        url = "https://api.openai.com/v1/chat/completions"
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.token}"
-        }
-        data = {
-            "model": "gpt-4o",
-            "messages": [{"role": "user", "content": question}],
-            "temperature": 0.7
-        }
-
-        response = requests.post(url, headers=headers, json=data)
-
-        return response.json()['choices'][0]['message']['content']
-
-
-class MockAIChat:
-    def __init__(self, token):
-        self.token = token
-
-    def ask(self, question):
-        return f"ANSWER {question}"
-
-
-def get_ai_chat(ai_config, token):
-    if ai_config == 'CHAT_GPT':
-        return ChatGPT(token)
-    else:
-        return MockAIChat(token)

web3_wizzard_lib/core/utils/benchmark_utils.py

@@ -1,12 +0,0 @@
-import time
-
-
-def benchmark(func):
-    def wrap(*args, **kwargs):
-        start = time.perf_counter()
-        result = func(*args, **kwargs)
-        end = time.perf_counter()
-        print(f"{func.__name__} executed in {end - start:.4f} seconds")
-        return result
-
-    return wrap

web3_wizzard_lib/core/utils/module_memory.py

@@ -1,28 +0,0 @@
-memory = {
-
-}
-
-def add_value(key, value):
-    memory[key] = value
-
-def add_memory_list(key, value):
-    memory[key] = value
-
-
-def accumulate_by_key(key, value):
-    if key not in memory:
-        memory[key] = []
-
-    memory[key].append(value)
-    # if isinstance(value, map):
-    #     (list(value))
-    # else:
-    #     memory[key] += value
-
-
-def remove_key(key):
-    del memory[key]
-
-
-def get_by_key(key):
-    return memory.get(key)