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

tests/core/modules/test_stargate_farming.py

@@ -0,0 +1,108 @@
+import unittest
+
+from loguru import logger
+from sybil_engine.config.app_config import set_network
+
+from web3_wizzard_lib.core.modules.stargate.farming import StargateFarmingModule
+from web3_wizzard_lib.core.modules.stargate.pool import get_pool_balance_for_chain
+from tests.core.modules.__init__ import test_account, init_set_test_config, test_min_native_balance
+
+# Module [STARGATE_FARMING, 14] Stargate farming
+test_stargate_farming_config = {
+    'chain': 'BASE',
+    'bridge_amount_interval': {'from': 1, 'to': 1},
+    'all_balance_mode': 0,
+    # 0 - all balance ignores CHAIN stakes blockchain with maximum balance
+    # 1 - all balance stakes all balance from CHAIN
+    'operation': {'ADD_TO_POOL', 'DEPOSIT', 'WITHDRAW', 'REDEEM_FROM_POOL'},
+    # 'operation': {'REDEEM_FROM_POOL'},
+    'token': 'ETH',  # ['ETH', 'USDC']
+    # 'operation': {'WITHDRAW', 'REDEEM_FROM_POOL'}
+    'operation_sleep_interval': {'from': 0, 'to': 0}
+}
+
+
+class TestStargateFarming(unittest.TestCase):
+    init_set_test_config()
+
+    def test_shouldStargateFarming(self):
+        logger.info("Test module [STARGATE_FARMING, 14]")
+
+        test_stargate_farming_config['bridge_amount_interval'] = {'from': 1, 'to': 1}
+        stargate_farming = StargateFarmingModule(test_min_native_balance, test_account)
+
+        try:
+            stargate_farming.execute(*stargate_farming.parse_params(test_stargate_farming_config), test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldStargateFarmingWithAllBalance(self):
+        logger.info("Test module [STARGATE_FARMING, 14]")
+
+        test_stargate_farming_config['bridge_amount_interval'] = 'all_balance'
+        stargate_farming = StargateFarmingModule(test_min_native_balance, test_account)
+
+        try:
+            stargate_farming.execute(*stargate_farming.parse_params(test_stargate_farming_config), test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldStargateFarmingWithAllBalanceMode1(self):
+        logger.info("Test module [STARGATE_FARMING, 14]")
+
+        test_stargate_farming_config['bridge_amount_interval'] = 'all_balance'
+        test_stargate_farming_config['all_balance_mode'] = 1
+
+        stargate_farming = StargateFarmingModule(test_min_native_balance, test_account)
+
+        try:
+            stargate_farming.execute(*stargate_farming.parse_params(test_stargate_farming_config), test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldStargateFarmingStepByStep(self):
+        set_network('LOCAL')
+
+        logger.info("Test module [STARGATE_FARMING, 14]")
+
+        test_stargate_farming_config['bridge_amount_interval'] = {'from': 10, 'to': 10}
+        test_stargate_farming_config['all_balance_mode'] = 1
+
+        stargate_farming = StargateFarmingModule(test_min_native_balance, test_account)
+
+        try:
+            #PREPARE
+            test_stargate_farming_config['operation'] = {'REDEEM_FROM_POOL'}
+            stargate_farming.execute(*stargate_farming.parse_params(test_stargate_farming_config), test_account)
+
+            chain, pool_balance_1, web3 = get_pool_balance_for_chain('BASE', 'ETH', test_account)
+
+            test_stargate_farming_config['operation'] = {'ADD_TO_POOL'}
+            stargate_farming.execute(*stargate_farming.parse_params(test_stargate_farming_config), test_account)
+
+            chain, pool_balance_2, web3 = get_pool_balance_for_chain('BASE', 'ETH', test_account)
+
+            self.assertAlmostEqual(
+                float(pool_balance_2.minus(pool_balance_1).readable()),
+                10.0,
+                delta=0.02
+            )
+
+            test_stargate_farming_config['operation'] = {'DEPOSIT'}
+            stargate_farming.execute(*stargate_farming.parse_params(test_stargate_farming_config), test_account)
+
+            test_stargate_farming_config['operation'] = {'WITHDRAW'}
+            stargate_farming.execute(*stargate_farming.parse_params(test_stargate_farming_config), test_account)
+
+            test_stargate_farming_config['operation'] = {'REDEEM_FROM_POOL'}
+            stargate_farming.execute(*stargate_farming.parse_params(test_stargate_farming_config), test_account)
+
+            chain, pool_balance_result, web3 = get_pool_balance_for_chain('BASE', 'ETH', test_account)
+
+            self.assertAlmostEqual(
+                first=pool_balance_result.readable(),
+                second=pool_balance_1.readable(),
+                delta=0.01
+            )
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")

tests/core/modules/test_warmup.py

@@ -0,0 +1,78 @@
+import unittest
+
+from loguru import logger
+from sybil_engine.domain.account_storage import AccountStorage
+from sybil_engine.utils.utils import ConfigurationException
+
+from web3_wizzard_lib.core.modules import WarmUp
+from tests.core.modules.__init__ import zksync_min_native_balance, init_set_test_config, \
+    test_min_native_balance, local_evm_test_account
+from tests.core.test_config import warmup_allowed_dex
+
+warmup_test_config = {
+    'auto_withdrawal': True,
+    'chain': 'LINEA',
+    'swap_amount_interval': {'from': 1, 'to': 1},
+    'token': 'ETH',
+    'amount_of_warmups': {'from': 3, 'to': 6},
+    'allowed_dex': ['syncswap', 'velocore', 'lineaswap', 'horizondex', 'pancake'],
+    # 'allowed_dex': warmup_allowed_dex,
+    'warmup_pairs': [],  # specify for warming up by concrete pair
+    'sell_tokens': True,
+    'pair_sleep_interval': {'from': 0, 'to': 0}  # Interval between different tokens warm up of 1 account
+}
+
+
+class TestWarmUp(unittest.TestCase):
+    def test_shouldWarmUp(self):
+        init_set_test_config()
+
+        logger.info("Test module [WARMUP, 1]")
+
+        warmup = WarmUp(test_min_native_balance, AccountStorage(), 3)
+        warmup_test_config['warmup_pairs'] = []
+
+        try:
+            warmup.execute(*warmup.parse_params(warmup_test_config), local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldWarmUpPair(self):
+        init_set_test_config()
+
+        logger.info("Test module [WARMUP, 1]")
+
+        warmup = WarmUp(zksync_min_native_balance, AccountStorage(), 3)
+        warmup_test_config['warmup_pairs'] = ['ETH>USDC']
+
+        try:
+            warmup.execute(*warmup.parse_params(warmup_test_config), local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldWarmUp2Pairs(self):
+        logger.info("Test module [WARMUP, 1]")
+
+        warmup_test_config['pair_sleep_interval'] = {'from': 0, 'to': 0}
+        warmup_test_config['allowed_dex'] = warmup_allowed_dex
+        warmup_test_config['warmup_pairs'] = ['ETH>USDC', 'ETH>USDT']
+
+        warmup = WarmUp(zksync_min_native_balance, AccountStorage(), 2)
+
+        try:
+            warmup.execute(*warmup.parse_params(warmup_test_config), local_evm_test_account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+    def test_shouldSkipNonExistingPair(self):
+        init_set_test_config()
+
+        logger.info("Test module [WARMUP, 1]")
+
+        warmup = WarmUp(zksync_min_native_balance, AccountStorage(), 3)
+        warmup_test_config['warmup_pairs'] = ['nonExisting']
+
+        with self.assertRaises(ConfigurationException):
+            warmup.execute(*warmup.parse_params(warmup_test_config), local_evm_test_account)
+
+

tests/core/modules/test_wrapping.py

@@ -0,0 +1,68 @@
+import decimal
+import unittest
+
+from loguru import logger
+from sybil_engine.data.networks import get_chain_instance_for_network
+from sybil_engine.domain.balance.tokens import WETHToken
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.modules import Wrapping
+from tests.core.modules.__init__ import  zksync_min_native_balance, init_set_test_config, \
+    local_evm_test_account
+
+
+class TestWrappingModule(unittest.TestCase):
+    init_set_test_config()
+
+    web3 = init_web3(get_chain_instance_for_network('SCROLL', 'LOCAL'), None)
+
+    def test_shouldWrapWETH(self, chain='SCROLL', account=local_evm_test_account):
+        logger.info("Test module [WRAPPING, 4] WRAP 1 ETH")
+
+        wrap_test_config = {
+            'chain': chain,
+            'action': 'UNWRAP',  # [WRAP, UNWRAP]
+            'amount_interval': {'from': 0, 'to': 0}
+        }
+
+        begin_balance = WETHToken(chain, self.web3).balance(account)
+
+        wrapping = Wrapping(zksync_min_native_balance, account)
+        wrap_test_config['action'] = 'WRAP'
+        wrap_test_config['amount_interval'] = {'from': 1, 'to': 1}
+
+        try:
+            wrapping.execute(*wrapping.parse_params(wrap_test_config), account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+
+        end_balance = WETHToken(chain, self.web3).balance(account)
+
+        self.assertEqual(end_balance.readable() - begin_balance.readable(), decimal.Decimal(1))
+
+    def test_shouldUnwrapWETH(self, chain='SCROLL', account=local_evm_test_account):
+        init_set_test_config()
+
+        logger.info("Test module [WRAPPING, 4] UNWRAP ALL ETH")
+
+        wrap_test_config = {
+            'chain': chain,
+            'action': 'UNWRAP',  # [WRAP, UNWRAP]
+            'amount_interval': {'from': 0, 'to': 0}
+        }
+
+        wrapping = Wrapping(zksync_min_native_balance, account)
+
+        wrap_test_config['action'] = 'UNWRAP'
+        wrap_test_config['amount_interval'] = 'all_balance'
+
+        try:
+            wrapping.execute(*wrapping.parse_params(wrap_test_config), account)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")
+        end_balance = WETHToken(chain, self.web3).balance(account)
+
+        self.assertEqual(
+            end_balance.readable(),
+            decimal.Decimal(0)
+        )

tests/core/scenario/module_0_test_config.py

@@ -0,0 +1,91 @@
+from tests.core.test_config import warmup_allowed_dex
+
+TEST_module_0_config = {
+    'scenario_name': 'TEST_module_0_config',
+    'scenario': [
+        {
+            'module': 'WARMUP',
+            'params': {
+                'chain': 'ZKSYNC',
+                'swap_amount_interval': {'from': 1, 'to': 1},
+                'token': 'ETH',
+                'amount_of_warmups': {'from': 5, 'to': 6},
+                'allowed_dex': warmup_allowed_dex,
+                'warmup_pairs': [],
+                'sell_tokens': True,
+                'pair_sleep_interval': {'from': 0, 'to': 0}
+            }
+        },
+        {
+            'module': 'NFT_MINTER',
+            'params': {
+                'nft_amount_interval': {'from': 2, 'to': 5},
+                'nft_modules': ["ZKS_DOMAIN", "ERA_DOMAIN", "OMNI_SEA", "MERKLY_MINTER", "L2_TELEGRAPH_MINTER"],
+                'sleep_interval': {'from': 0, 'to': 0}
+            }
+        },
+        {
+            'module': 'LENDING',
+            'params': {
+                'amount': {'from': 0.001, 'to': 0.001},
+                # 'amount': 'all_balance',
+                'action': 'DEPOSIT+WITHDRAW',  # ['DEPOSIT', WITHDRAW', DEPOSIT+WITHDRAW, WITHDRAW_ALL]
+                'lending_apps': ['ERALEND', 'REACTOR_FUSION', 'BASILISK'],  # ['ERALEND', 'REACTOR_FUSION', 'BASILISK'],
+                'withdraw_sleep_interval': {'from': 0, 'to': 0},
+                'repeats': {'from': 4, 'to': 4}  # Количество повторов
+                # Интервал между депозитом и выводом, используется только при 'action' DEPOSIT+WITHDRAW
+            }
+        },
+        {
+            'module': 'DMAIL',
+            'params': {
+                'chain': 'ZKSYNC',
+                'email_amount': {'from': 3, 'to': 6}
+            }
+        },
+        {
+            'module': 'SELL_ALL',
+            'params': {
+                'chain': 'ZKSYNC',
+                'receive_token': 'ETH',  # [USDC, ETH]
+                'sleep_interval': {'from': 0, 'to': 0}  # Interval between selling different tokens of 1 account
+            }
+        },
+        {
+            'module': 'WRAPPING',
+            'params': {
+                'chain': 'ZKSYNC',
+                'amount_interval': 'all_balance',
+                'action': 'UNWRAP'  # [WRAP, UNWRAP]
+            }
+        },
+        {
+            'module': 'SEND_TO_CEX',
+            'params': {
+                'chain': 'ZKSYNC',
+                'amount': {'from': 1, 'to': 1}
+            }
+        },
+        {
+            'module': 'WARMUP',
+            'params': {
+                'chain': 'ZKSYNC',
+                'swap_amount_interval': {'from': 1, 'to': 1},
+                'token': 'ETH',
+                'amount_of_warmups': {'from': 5, 'to': 6},
+                'allowed_dex': warmup_allowed_dex,
+                'warmup_pairs': [],
+                'sell_tokens': True,
+                'pair_sleep_interval': {'from': 0, 'to': 0}
+            }
+        },
+        {
+            'module': 'NFT_MINTER',
+            'params': {
+                'nft_amount_interval': {'from': 2, 'to': 5},
+                'nft_modules': ["ZKS_DOMAIN", "ERA_DOMAIN", "OMNI_SEA", "MERKLY_MINTER", "L2_TELEGRAPH_MINTER"],
+                'sleep_interval': {'from': 0, 'to': 0}
+            }
+        }
+    ]
+}

tests/core/test_app.py

@@ -0,0 +1,19 @@
+import unittest
+
+from loguru import logger
+from sybil_engine.app import launch_app
+
+from tests.core.scenario.module_0_test_config import TEST_module_0_config
+from tests.core.test_config import create_config, args
+
+
+class TestApp(unittest.TestCase):
+
+    def test_moduleScenario(self):
+        logger.info("Test module [SCENARIO, 0]")
+        config = create_config()
+
+        try:
+            launch_app(args, TEST_module_0_config, config)
+        except Exception as e:
+            self.fail(f"Some function raised an exception: {e}")

tests/core/test_config.py

@@ -0,0 +1,34 @@
+import argparse
+import os
+
+from data.config_default import cex_data, auto_withdrawal, withdraw_interval, proxy_mode, gas_prices
+from data.module_config_default import min_native_interval
+
+cdir = os.getcwd()
+proxy_file = f'{cdir}/tests/proxy.txt'
+args = argparse.Namespace(password='test', private_keys=f'{cdir}/tests/private_keys.txt',
+                          cex_addresses=f'{cdir}/tests/cex_addresses.txt',
+                          starknet_addresses=f'{cdir}/tests/starknet_addresses.txt',
+                          proxy_file=f'{cdir}/tests/proxy.txt',
+                          network='LOCAL')
+
+
+sleep_interval = {'from': 0, 'to': 0}
+swap_retry_sleep_interval = {'from': 0, 'to': 0}
+encryption = False
+warmup_allowed_dex = ['syncswap', 'mute', 'velocore']
+
+
+def scenario_from_module(module_config, scenario_name):
+    return {
+        'scenario_name': scenario_name,
+        'scenario': [
+            module_config
+        ]
+    }
+
+
+def create_config():
+    cex_config = (cex_data, auto_withdrawal, withdraw_interval)
+
+    return None, encryption, min_native_interval, proxy_mode, cex_config, sleep_interval, swap_retry_sleep_interval, gas_prices

web3_wizzard_lib/core/__init__.py

@@ -0,0 +1 @@
+

web3_wizzard_lib/core/contract/aavecontract.py

@@ -0,0 +1,36 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/aave.json")
+
+
+class AaveContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def depositETH(self, account, amount: int):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, set_contract_address=False)
+
+        txn_params['value'] = amount
+
+        return self.contract.functions.depositETH(
+            '0x11fCfe756c05AD438e312a7fd934381537D3cFfe',
+            account.address,
+            0
+        ).build_transaction(txn_params)
+
+    @evm_transaction
+    def withdrawETH(self, account, amount: int):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+
+        return self.contract.functions.withdrawETH(
+            '0x11fCfe756c05AD438e312a7fd934381537D3cFfe',
+            amount,
+            account.address
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/alienswap_contract.py

@@ -0,0 +1,21 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/abbysworld.json")
+
+
+class AlienSwapContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def purchase(self, account, amount):
+        txn_params = self.build_generic_data(account.address, True)
+
+        txn_params['value'] = 100000000000000
+
+        txn_params['data'] = '0xefef39a10000000000000000000000000000000000000000000000000000000000000001'
+        txn_params['gasPrice'] = self.web3.eth.gas_price
+
+        return txn_params

web3_wizzard_lib/core/contract/arena_games_contract.py

@@ -0,0 +1,16 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/arena_games.json")
+
+
+class ArenaGamesContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def safe_mint(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.safeMint(account.address).build_transaction(txn_params)

web3_wizzard_lib/core/contract/basiliskcontract.py

@@ -0,0 +1,58 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/basiliks.json")
+
+
+class BasiliskContract(Contract):
+
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def get_deposit_amount(self, account):
+        return self.contract.functions.balanceOfUnderlying(account.address).call()
+
+    @evm_transaction
+    def mint(self, account, amount_wei):
+        tx_data = self.build_generic_data(account.address)
+
+        tx_data['data'] = self.contract.encode_abi('mint', args=())
+        tx_data['gas'] = int(self.web3.eth.estimate_gas(tx_data) * 1.1)
+
+        tx_data.update({"value": amount_wei})
+
+        return tx_data
+
+    @evm_transaction
+    def redeem_underlying(self, account, amount):
+        tx_data = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.redeemUnderlying(amount).build_transaction(tx_data)
+
+    # @evm_transaction
+    # def enable_collateral(self):
+    #     logger.info(f"[{self.account_id}][{self.address}] Enable collateral on basilisk.py")
+    #
+    #     contract = self.get_contract(BASILISK_CONTRACTS["collateral"], BASILISK_ABI)
+    #
+    #     tx_data = await self.get_tx_data()
+    #
+    #     transaction = await contract.functions.enterMarkets(
+    #         [Web3.to_checksum_address(BASILISK_CONTRACTS["landing"])]
+    #     ).build_transaction(tx_data)
+    #
+    #     return transaction
+    #
+    # @evm_transaction
+    # def disable_collateral(self):
+    #     logger.info(f"[{self.account_id}][{self.address}] Disable collateral on basilisk.py")
+    #
+    #     contract = self.get_contract(BASILISK_CONTRACTS["collateral"], BASILISK_ABI)
+    #
+    #     tx_data = await self.get_tx_data()
+    #     transaction = await contract.functions.exitMarket(
+    #         Web3.to_checksum_address(BASILISK_CONTRACTS["landing"])
+    #     ).build_transaction(tx_data)
+    #
+    #     return transaction

web3_wizzard_lib/core/contract/bilinear_contract.py

@@ -0,0 +1,22 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/bilinear.json")
+
+
+class BilinearContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def claim(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.claim(
+            [],
+            ([], [1]),
+            ([], [], []),
+            0,
+            '0x307b8d76e3a3ca16066982ae42768878ec07a1b9af2679f2f9b8a3c3db25e7d5'
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/bungee.py

@@ -0,0 +1,33 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/bungee.json")
+
+bungee_chain_ids = {
+    "BSC": 56,
+    "OPTIMISM": 10,
+    "POLYGON": 137,
+    "BASE": 8453,
+    "ARBITRUM": 42161,
+    "AVALANCHE": 43114,
+    "ZK_EVM": 1101,
+    "ZKSYNC": 324
+}
+
+
+class Bungee(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def refuel(self, account, to_chain, amount):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+        txn_params['value'] = amount
+
+        return self.contract.functions.depositNativeToken(
+            bungee_chain_ids[to_chain],
+            sender
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/coredao_contract.py

@@ -0,0 +1,35 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import l0_evm_transaction
+
+with open("resources/abi/coredao.json") as f:
+    abi = f.read()
+
+
+class CoreDaoContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @l0_evm_transaction
+    def bridge(self, account, amount, token, fee, to_chain):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = fee
+
+        contract_txn = self.contract.functions.bridge(
+            token,
+            amount.wei,
+            account.address,
+            (
+                account.address,
+                '0x0000000000000000000000000000000000000000'
+            ),
+            b''
+        ).build_transaction(txn_params)
+
+        return contract_txn
+
+    def estimate_bridge_fee(self):
+        return self.contract.functions.estimateBridgeFee(
+            False,
+            b''
+        ).call()[0]