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

web3_wizzard_lib/core/modules/warm_up.py

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

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

@@ -0,0 +1,63 @@
+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/sub_module.py

@@ -0,0 +1,8 @@
+class SubModule:
+    module_name = None
+
+    def execute(self, *args):
+        pass
+
+    def log(self):
+        pass

web3_wizzard_lib/launcher.py

@@ -0,0 +1,39 @@
+import glob
+import importlib
+import os
+
+from sybil_engine.module.modules import *
+from loguru import logger
+from sybil_engine.app import launch_with_data
+from sybil_engine.utils.configuration_loader import load_module_vars
+
+import web3_wizzard_lib.core.modules
+from web3_wizzard_lib.core.modules.swap.swap_list import swap_facade
+import importlib.util
+
+
+def import_all_modules(package):
+    # Get the directory path of the package
+    package_dir = os.path.dirname(package.__file__)
+
+    # Get all .py files in that directory
+    python_files = glob.glob(package_dir + "/*.py")
+
+    for file in python_files:
+        # Get module name from file name by removing the extension
+        module_name = os.path.basename(file)[:-3]
+        # Form the absolute module path by 'package.module'
+        absolute_module_name = f'{package.__name__}.{module_name}'
+        # Import the module using its absolute path
+        importlib.import_module(absolute_module_name)
+
+
+def launch():
+    import_all_modules(web3_wizzard_lib.core.modules)
+
+    logger.info(Module.__subclasses__())
+
+    modules_data = Modules(None, swap_facade)
+    #modules_data = load_module_vars("web3_wizzard_lib.core.modules")['modules_data']
+
+    launch_with_data(modules_data)

web3_wizzard_lib-0.0.2.data/data/requirements.txt

@@ -0,0 +1 @@
+sybil-engine==9.9.0

web3_wizzard_lib-0.0.2.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: web3_wizzard_lib
+Version: 0.0.2
+Summary: Engine for web3 smart contracts automatization.
+Home-page: https://github.com/Indeoo/web3-wizzard-lib/
+Author: Indeoo
+Author-email: indeooars@gmail.com
+Description-Content-Type: text/markdown
+Requires-Dist: sybil-engine==9.9.0
+