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

web3_wizzard_lib/core/modules/bank/reactorfusion.py

@@ -0,0 +1,25 @@
+from sybil_engine.contract.weth import WETH
+from sybil_engine.data.networks import get_ids_chain
+from sybil_engine.data.tokens import get_tokens_for_chain
+
+from web3_wizzard_lib.core.contract.reactor_fusion_contract import ReactorFusionContract
+from web3_wizzard_lib.core.modules.bank.bank import Bank
+
+
+class ReactorFusion(Bank):
+    app_name = 'REACTORFUSION_LANDING'
+    supported_chains = ['ZKSYNC']
+
+    def __init__(self, contract, web3):
+        self.contract = ReactorFusionContract(contract, web3)
+
+    def supply(self, account, amount):
+        self.contract.mint(account, amount.wei)
+
+    def redeem(self, account, withdraw):
+        self.contract.redeem_underlying(account, withdraw.wei)
+
+    def get_deposit_amount(self, account, token):
+        weth_token = get_tokens_for_chain(get_ids_chain()[self.contract.web3.eth.chain_id])['REACTORFUSION_LANDING']
+
+        return WETH(weth_token, self.contract.web3).balance_of(account)

web3_wizzard_lib/core/modules/bank/zerolend.py

@@ -0,0 +1,36 @@
+from loguru import logger
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.domain.balance.tokens import Erc20Token
+
+from web3_wizzard_lib.core.contract.zerolend_contract import ZeroLendContract
+from web3_wizzard_lib.core.modules.bank.bank import Bank
+
+
+class ZeroLend(Bank):
+    app_name = 'ZEROLEND'
+    supported_chains = ['LINEA']
+
+    def __init__(self, chain, web3):
+        self.chain = chain
+        self.web3 = web3
+        self.contract = ZeroLendContract(get_contracts_for_chain(self.chain)['ZEROLEND_LEND'], self.web3)
+
+    def supply(self, account, amount):
+        logger.info(f"Deposit {amount} to ZEROLEND")
+
+        self.contract.deposit_eth(account, amount.wei)
+
+    def redeem(self, account, amount):
+        erc20_token = Erc20Token('LINEA', get_tokens_for_chain(self.chain)['ZEROLEND_WETH'], self.web3)
+
+        if erc20_token.allowance(account, self.contract.contract_address) < 100:
+            erc20_token.approve(account, self.contract.contract_address)
+
+        self.contract.withdraw_eth(account, amount.wei)
+
+    def get_deposit_amount(self, account, token):
+        erc20_token = Erc20Token('LINEA', get_tokens_for_chain(self.chain)['ZEROLEND_WETH'], self.web3)
+
+        return erc20_token.balance(account)
+

web3_wizzard_lib/core/modules/bank_module.py

@@ -0,0 +1,99 @@
+from loguru import logger
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance_utils import get_native_balance, interval_to_eth_balance, \
+    interval_to_erc20_balance
+from sybil_engine.module.module import Order, Module
+from sybil_engine.utils.app_account_utils import AppAccount
+from sybil_engine.utils.retry import retry
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.modules.bank.basilisk import Basilisk
+from web3_wizzard_lib.core.modules.bank.eralend import Eralend
+from web3_wizzard_lib.core.modules.bank.layerbank import LayerBank
+from web3_wizzard_lib.core.modules.bank.mendi_finance import MendiFinance
+from web3_wizzard_lib.core.modules.bank.aave import Aave
+from web3_wizzard_lib.core.modules.bank.reactorfusion import ReactorFusion
+from web3_wizzard_lib.core.modules.bank.zerolend import ZeroLend
+
+
+class Banking(Module):
+    module_name = 'BANKING'
+    random_order = Order.RANDOM
+    module_config = 'banking_config'
+
+    @retry(max_attempts=10, retry_interval={'from': 10, 'to': 20})
+    def execute(self, bank_app_name, action, token, amount_interval, chain, account: AppAccount):
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+        balance = get_native_balance(account, web3, chain_instance)
+
+        logger.info(f"Balance {balance}")
+
+        if token == 'ETH':
+            amount = interval_to_eth_balance(amount_interval, account, chain, web3)
+        else:
+            amount = interval_to_erc20_balance(amount_interval, account, token, chain, web3)
+
+        bank_app = self.get_bank_app(bank_app_name, chain, web3)
+
+        logger.info(f"{bank_app.app_name}")
+
+        self.perform_action(bank_app, action, amount, token, account)
+
+    def perform_action(self, bank_app, action, amount, token, account):
+        logger.info(action)
+        if action == 'SUPPLY':
+            bank_app.supply(account, amount)
+        elif action == 'BORROW':
+            bank_app.borrow(account, amount)
+        elif action == 'REPAY':
+            bank_app.repay_borrow(account, amount)
+        elif action == 'REDEEM':
+            amount = bank_app.get_deposit_amount(account, token)
+            logger.info(f"Redeem {amount} of {token} from {bank_app.app_name}")
+
+            bank_app.redeem(account, amount, token)
+        else:
+            raise ConfigurationException("Unsupported action")
+
+    def get_bank_app(self, bank_app, chain, web3):
+        bank_app = self.get_bank_app_by_name(bank_app)
+
+        if chain not in bank_app.supported_chains:
+            raise ConfigurationException(
+                f"{bank_app} not supported in {chain}. Supported chains: {bank_app.supported_chains}")
+
+        return bank_app(chain, web3)
+
+    def get_bank_app_by_name(self, bank_app_name):
+        for bank_app in self.get_bank_apps():
+            if bank_app.app_name == bank_app_name:
+                return bank_app
+        raise ConfigurationException(f"No Bank App with name {bank_app_name} found")
+
+    def get_bank_apps(self):
+        return {
+            Basilisk,
+            ReactorFusion,
+            Eralend,
+            MendiFinance,
+            LayerBank,
+            Aave,
+            ZeroLend
+        }
+
+    def log(self):
+        return "BANKING"
+
+    def parse_params(self, module_params):
+        if 'chain' not in module_params:
+            module_params['chain'] = 'LINEA'
+
+        return [
+            module_params['bank'],
+            module_params['action'],
+            module_params['token'],
+            module_params['amount_interval'],
+            module_params['chain']
+        ]

web3_wizzard_lib/core/modules/bridge/bridge.py

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

web3_wizzard_lib/core/modules/bridge/coredao_bridge_sub.py

@@ -0,0 +1,47 @@
+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 import NotEnoughERC20Balance
+from sybil_engine.domain.balance.balance_utils import interval_to_erc20_balance, get_native_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.utils.retry import retry
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.coredao_contract import CoreDaoContract
+from web3_wizzard_lib.core.contract.coredao_from_contract import CoreDaoFromContract
+from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
+
+
+class CoreDaoBridgeSubModule(Bridge):
+    supported_chains = ['POLYGON', 'COREDAO']
+
+    @retry(max_attempts=5, retry_interval={'from': 60 * 15, 'to': 60 * 25})
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
+        chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        erc20_token = Erc20Token(from_chain, token, web3)
+
+        amount = interval_to_erc20_balance(bridge_amount_interval, account, token, from_chain, web3)
+
+        logger.info(f"Native balance: {get_native_balance(account, web3, chain_instance)}")
+        logger.info(f"Balance: {erc20_token.balance(account)}")
+
+        logger.info(f"Bridge {from_chain + ' -> ' + to_chain} {amount}")
+
+        if amount.wei == 0:
+            raise NotEnoughERC20Balance(f"Can't swap zero balance")
+
+        coredao_contract = get_contracts_for_chain(from_chain)['COREDAO_BRIDGE']
+
+        if erc20_token.allowance(account, coredao_contract) < amount.wei:
+            erc20_token.approve(account, coredao_contract)
+
+        if from_chain == 'COREDAO':
+            coredao = CoreDaoFromContract(coredao_contract, web3)
+            fee = coredao.estimate_bridge_fee(to_chain)
+        else:
+            coredao = CoreDaoContract(coredao_contract, web3)
+            fee = coredao.estimate_bridge_fee()
+
+        coredao.bridge(account, amount, erc20_token.erc20_contract.contract_address, fee, to_chain)

web3_wizzard_lib/core/modules/bridge/orbiter_sub.py

@@ -0,0 +1,112 @@
+import random
+
+from loguru import logger
+from sybil_engine.contract.erc20contract import Erc20Contract
+from sybil_engine.contract.send import Send
+from sybil_engine.data.contracts import get_contracts_for_chain
+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_erc20_balance, \
+    interval_to_native_balance, verify_balance
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.orbiter_starknet import OrbiterStarknet
+from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
+
+bridge_codes = {
+    "ETH": 9001,
+    "ARBITRUM": 9002,
+    "POLYGON": 9006,
+    "OPTIMISM": 9007,
+    "BSC": 9015,
+    "ARBITRUM_NOVA": 9016,
+    "ZKSYNC": 9014,
+    "POLYGON_ZK": 9017,
+    "BASE": 9021,
+    "LINEA": 9023,
+    "SCROLL": 9019,
+    #"X_LAYER": 9027, DONT USE
+    "ZORA": 9030,
+    "MANTA": 9031,
+    "ZKFAIR": 9038
+}
+
+
+class OrbiterSubModule(Bridge):
+    supported_tokens = ['NATIVE', 'USDC', 'USDT', 'WETH']
+
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
+        from_chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(from_chain_instance, account.proxy)
+
+        if isinstance(to_chain, list):
+            to_chain = random.choice(to_chain)
+        if to_chain not in bridge_codes:
+            raise ConfigurationException(f"{to_chain} not supported in orbiter")
+
+        amount = self.__calculate_bridge_amount(account, bridge_amount_interval, from_chain_instance, to_chain, token,
+                                                min_native_balance, web3)
+
+        logger.info(f"Bridge {from_chain} –> {to_chain} | {amount}")
+        self.__perform_bridge(account, amount, from_chain, to_chain, token, web3)
+
+    def __perform_bridge(self, account, amount, from_chain, to_chain, token, web3):
+        if token == 'NATIVE':
+            self.__bridge_native(account, amount, from_chain, to_chain, web3)
+        else:
+            self.__bridge_token(account, amount, from_chain, web3)
+
+    def __calculate_bridge_amount(self, account, bridge_amount_interval, from_chain_instance, to_chain, token,
+                                  min_native_balance, web3):
+        if token == 'NATIVE':
+            native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
+
+            amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
+            if amount.wei > native_without_min.wei:
+                if bridge_amount_interval == 'all_balance':
+                    amount = native_without_min
+                else:
+                    raise NotEnoughNativeBalance(
+                        f"The account balance ({native_without_min}) < bridging amount ({amount}).")
+        else:
+            amount = interval_to_erc20_balance(bridge_amount_interval, account, token, from_chain_instance['chain'],
+                                               web3)
+            if bridge_amount_interval == 'all_balance':
+                amount.wei = amount.wei - 10 ** 5
+
+        amount.wei = self.__adjust_amount_by_bridge_code(amount.wei, to_chain)
+
+        return amount
+
+    def __adjust_amount_by_bridge_code(self, wei_amount, to_chain):
+        bridge_code = bridge_codes.get(to_chain)
+        if not bridge_code:
+            raise ConfigurationException(f"No bridge code found for {to_chain}")
+        return int(f"{wei_amount // 10 ** 4}{bridge_code}")
+
+    def __bridge_native(self, account, amount, from_chain, to_chain, web3):
+        if to_chain == 'STARKNET':
+            if amount.readable() <= 0.0065 or amount.readable() >= 5:
+                raise NotEnoughNativeBalance(f"Limit range amount for starknet 0.0065 – 5 ETH | {amount}")
+
+            if from_chain != 'ZKSYNC':
+                raise ConfigurationException("only ZKSYNC can bridge to STARKNET")
+
+            orbiter_wallet = get_contracts_for_chain(from_chain)['ORBITER_STARKNET']
+            orbiter_starknet = OrbiterStarknet(orbiter_wallet, web3)
+            orbiter_starknet.bridge(account, amount)
+        else:
+            orbiter_wallet = get_contracts_for_chain(from_chain)['ORBITER']
+            send = Send(orbiter_wallet, web3)
+            send.send_to_wallet(account, orbiter_wallet, amount)
+
+    def __bridge_token(self, account, amount, from_chain, web3):
+        contracts = get_contracts_for_chain(from_chain)
+
+        if 'ORBITER_ERC20' not in contracts:
+            raise ConfigurationException(f"ERC20 is not supported for {from_chain}")
+
+        erc20 = Erc20Contract(get_tokens_for_chain(from_chain)[amount.token], web3)
+        erc20.transfer(account, amount, contracts['ORBITER_ERC20'])

web3_wizzard_lib/core/modules/bridge/scroll_bridge_sub.py

@@ -0,0 +1,42 @@
+from sybil_engine.utils.utils import ConfigurationException
+
+from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
+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 NotEnoughNativeBalance
+from sybil_engine.domain.balance.balance_utils import interval_to_native_balance, verify_balance
+
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.eth_scroll_bridge_contract import EthScrollBridgeContract
+from web3_wizzard_lib.core.contract.scroll_bridge_contract import ScrollBridgeContract
+from web3_wizzard_lib.core.contract.scroll_oracle import ScrollOracle
+
+class ScrollBridgeSubModule(Bridge):
+
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
+        from_chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(from_chain_instance, account.proxy)
+        native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
+        amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
+        if amount.wei > native_without_min.wei:
+            if bridge_amount_interval == 'all_balance':
+                amount = native_without_min
+            else:
+                raise NotEnoughNativeBalance(
+                    f"The account balance ({native_without_min}) < bridging amount ({amount}).")
+        if from_chain == 'ETH_MAINNET':
+            contract_oracle = get_contracts_for_chain(from_chain)["SCROLL_ORACLE"]
+            fee = ScrollOracle(contract_oracle, web3).estimateCrossDomainMessageFee()
+
+            scroll_bridge_contract_address = get_contracts_for_chain(from_chain)["SCROLL_BRIDGE"]
+            scroll_bridge = EthScrollBridgeContract(scroll_bridge_contract_address, web3)
+
+            scroll_bridge.sendMessage(account, amount.wei, fee)
+        elif from_chain == 'SCROLL':
+            scroll_bridge_contract_address = get_contracts_for_chain(from_chain)["SCROLL_BRIDGE"]
+            scroll_bridge = ScrollBridgeContract(scroll_bridge_contract_address, web3)
+
+            scroll_bridge.withdraw(account, amount.wei)
+        else:
+            raise ConfigurationException(f"{from_chain} chain is unsupported, only ETH_MAINNET and SCROLL allowed")

web3_wizzard_lib/core/modules/bridge/stargate_v2_sub.py

@@ -0,0 +1,74 @@
+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 import NotEnoughNativeBalance
+from sybil_engine.domain.balance.balance_utils import interval_to_native_balance, verify_balance
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.stargate_v2_contract import StargateV2Contract
+from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
+
+chain_ids = {
+    'LINEA': 30183,
+    'SCROLL': 30214,
+    'OPTIMISM': 30111,
+    'ARBITRUM': 30110,
+    'BASE': 30184
+}
+
+
+class StargateV2SubModule(Bridge):
+    supported_tokens = ['NATIVE']
+
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
+        if token != 'NATIVE':
+            raise ConfigurationException('Currently only native token bridge is supported by Stargate V2')
+
+        from_chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(from_chain_instance, account.proxy)
+        stargate_v2_contract = get_contracts_for_chain(from_chain)['STARGATE_V2']
+
+        amount = self.__calculate_bridge_amount(
+            account,
+            bridge_amount_interval,
+            from_chain_instance,
+            min_native_balance,
+            web3
+        )
+
+        logger.info(f"Bridge {from_chain} –> {to_chain} | {amount}")
+
+        send_params = (
+            chain_ids[to_chain],
+            f'0x000000000000000000000000{account.address[2:]}',
+            amount.wei,  # amountLD,
+            int(amount.wei * 0.995),  # minAmountLd,
+            b'',
+            b'',
+            b'\x01',
+        )
+
+        stargate_v2 = StargateV2Contract(stargate_v2_contract, web3)
+
+        stargate_fee = stargate_v2.quote_send(send_params)
+
+        stargate_v2.send(
+            account,
+            amount.wei + stargate_fee[0],
+            send_params,
+            stargate_fee,
+            account.address
+        )
+
+    def __calculate_bridge_amount(self, account, bridge_amount_interval, from_chain_instance, min_native_balance, web3):
+        native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
+
+        amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
+        if amount.wei > native_without_min.wei:
+            if bridge_amount_interval == 'all_balance':
+                amount = native_without_min
+            else:
+                raise NotEnoughNativeBalance(
+                    f"The account balance ({native_without_min}) < bridging amount ({amount}).")
+        return amount

web3_wizzard_lib/core/modules/bridge_module.py

@@ -0,0 +1,47 @@
+from sybil_engine.module.module import Module
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.validation_utils import validate_amount_interval, validate_chain
+
+from web3_wizzard_lib.core.modules.bridge.coredao_bridge_sub import CoreDaoBridgeSubModule
+from web3_wizzard_lib.core.modules.bridge.orbiter_sub import OrbiterSubModule
+from web3_wizzard_lib.core.modules.bridge.scroll_bridge_sub import ScrollBridgeSubModule
+from web3_wizzard_lib.core.modules.bridge.stargate_v2_sub import StargateV2SubModule
+
+
+class BridgeModule(Module):
+    module_name = 'BRIDGE'
+    module_config = 'bridge_module'
+
+    supported_tokens = ['NATIVE', 'USDC', 'USDT', 'WETH']
+
+    def execute(self, bridge, bridge_amount_interval, from_chain, to_chain, token, account):
+        if bridge == 'ORBITER':
+            module = OrbiterSubModule()
+        elif bridge == 'STARGATE_V2':
+            module = StargateV2SubModule()
+        elif bridge == 'COREDAO':
+            module = CoreDaoBridgeSubModule()
+        elif bridge == 'SCROLL':
+            module = ScrollBridgeSubModule()
+        else:
+            raise ConfigurationException(f'Bridge {bridge} is not supported')
+
+        module.execute(bridge_amount_interval, from_chain, to_chain, token, self.min_native_balance, account)
+
+    def log(self):
+        return "BRIDGE"
+
+    def parse_params(self, module_params):
+        validate_amount_interval(module_params['bridge_amount_interval'])
+        validate_chain(module_params['from_chain'])
+
+        if 'token' not in module_params:
+            module_params['token'] = 'NATIVE'
+
+        if module_params['token'] not in self.supported_tokens:
+            raise ConfigurationException(
+                f"{module_params['token']} not supported in orbiter. Supported options: {self.supported_tokens}")
+
+        return module_params['bridge'], module_params['bridge_amount_interval'], module_params['from_chain'], \
+            module_params['to_chain'], \
+            module_params['token']

web3_wizzard_lib/core/modules/bungee.py

@@ -0,0 +1,109 @@
+from typing import Union
+
+import requests
+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, interval_to_eth_balance, from_wei_to_eth
+from sybil_engine.module.module import Module
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.validation_utils import validate_chain, validate_refuel_interval
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.bungee import bungee_chain_ids, Bungee
+
+
+class BungeeRefuel(Module):
+    module_name = 'BUNGEE'
+    module_config = 'bungee_config'
+
+    def execute(self, refuel_amount_interval, from_chain, to_chain, account):
+        from_chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(from_chain_instance, account.proxy)
+
+        bungee_contract = get_contracts_for_chain(from_chain)['BUNGEE']
+        bungee = Bungee(bungee_contract, web3)
+
+        try:
+            limits = self.get_bungee_limits(from_chain)
+
+            to_chain_limits = [
+                chain for chain in limits if chain["chainId"] == bungee_chain_ids[to_chain] and chain["isEnabled"]
+            ]
+
+            if to_chain_limits:
+                min_amount = float(from_wei_to_eth(int(to_chain_limits[0]["minAmount"])))
+                max_amount = float(from_wei_to_eth(int(to_chain_limits[0]["maxAmount"])))
+
+                if refuel_amount_interval == 'max':
+                    refuel_amount_interval = {'from': max_amount * 0.9, 'to': max_amount * 0.98}
+
+                if refuel_amount_interval == '':
+                    refuel_amount_interval = {'from': min_amount, 'to': max_amount}
+
+                if refuel_amount_interval['from'] < min_amount:
+                    raise ConfigurationException(
+                        f'Min refuel amount for {from_chain} is {min_amount} < {refuel_amount_interval["from"]}')
+
+                if refuel_amount_interval['to'] > max_amount:
+                    raise ConfigurationException(
+                        f'Max refuel amount for {from_chain} is {max_amount} > {refuel_amount_interval["to"]}')
+
+                native_without_min = get_native_balance(account, web3, from_chain_instance).minus(
+                    self.min_native_balance)
+
+                amount = interval_to_eth_balance(refuel_amount_interval, account, from_chain, web3)
+
+                if amount.wei > native_without_min.wei:
+                    amount = native_without_min
+
+                logger.info(f"Refuel {from_chain.title()} > {to_chain.title()} | {amount}")
+
+                bungee.refuel(account, to_chain, amount.wei)
+            else:
+                logger.info("skip")
+        except Exception as e:
+            logger.error(f"Bungee refuel error | error {e}")
+
+    def get_bungee_limits(self, from_chain) -> Union[dict, bool]:
+        bungee_data = self.get_bungee_data()
+
+        try:
+            if from_chain == 'ZKSYNC':
+                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "zkSync"][0]["limits"]
+            elif from_chain == 'ARBITRUM':
+                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Arbitrum"][0]["limits"]
+            elif from_chain == 'OPTIMISM':
+                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Optimism"][0]["limits"]
+            elif from_chain == 'POLYGON':
+                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Polygon"][0]["limits"]
+            elif from_chain == 'AVALANCHE':
+                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Avalanche"][0]["limits"]
+            elif from_chain == 'BSC':
+                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "BSC"][0]["limits"]
+            elif from_chain == 'BASE':
+                limits = [chain_data for chain_data in bungee_data if chain_data["name"] == "Base"][0]["limits"]
+            else:
+                raise Exception("Not supported")
+
+            return limits
+        except Exception as e:
+            return False
+
+    def get_bungee_data(self):
+        url = "https://refuel.socket.tech/chains"
+        response = requests.get(url)
+        if response.status_code == 200:
+            data = response.json()["result"]
+            return data
+        return False
+
+    def log(self):
+        return "BUNGEE REFUEL"
+
+    def parse_params(self, module_params):
+        validate_chain(module_params['from_chain'])
+        validate_chain(module_params['to_chain'])
+        validate_refuel_interval(module_params['refuel_amount_interval'])
+
+        return module_params['refuel_amount_interval'], module_params['from_chain'], module_params['to_chain']

web3_wizzard_lib/core/modules/cex_sender.py

@@ -0,0 +1,60 @@
+from loguru import logger
+from sybil_engine.contract.send import Send
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance_utils import interval_to_native_balance, interval_to_erc20_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.module.module import Module
+from sybil_engine.utils.accumulator import add_accumulator_native_balance
+from sybil_engine.utils.retry import retry
+from sybil_engine.utils.validation_utils import validate_chain, validate_amount_interval
+from sybil_engine.utils.web3_utils import init_web3
+
+
+class SendToCex(Module):
+    module_name = 'SEND_TO_CEX'
+    module_config = 'send_to_cex_config'
+    supported_chains = ['USDC', 'USDT', 'ZK', 'ZRO', 'OBT']
+
+    def execute(self, chain, send_to_cex_amount_interval, token, account):
+        cex_address = account.cex_address
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        if token == 'NATIVE':
+            amount = interval_to_native_balance(send_to_cex_amount_interval, account, chain_instance['chain'], web3)
+
+            if send_to_cex_amount_interval == 'all_balance':
+                amount = amount.minus(self.min_native_balance)
+        elif token in self.supported_chains:
+            amount = interval_to_erc20_balance(send_to_cex_amount_interval, account, token, chain, web3)
+        else:
+            raise Exception(f"Token {token} not supported. Only NATIVE and USDC/USDT are supported.")
+
+        if amount.wei == 0 :
+            logger.info("Wallet is empty")
+            return
+
+        self.send_funds(account, amount, cex_address, chain, chain_instance, token, web3)
+
+        add_accumulator_native_balance("Total sent to cex", amount.wei)
+
+    @retry(max_attempts=5, retry_interval={'from': 60 * 2, 'to': 60 * 3})
+    def send_funds(self, account, amount, cex_address, chain, chain_instance, token, web3):
+        logger.info(f"Send {amount} to {cex_address} ({chain_instance['chain']})")
+        if token == 'NATIVE':
+            send = Send(None, web3)
+            send.send_to_wallet(account, cex_address, amount)
+        elif token in self.supported_chains:
+            erc20_token = Erc20Token(chain, token, web3)
+            erc20_token.transfer(amount, cex_address, account)
+        else:
+            raise Exception(f"Token {token} not supported. Only NATIVE and USDC/USDT are supported.")
+
+    def log(self):
+        return "SEND TO CEX"
+
+    def parse_params(self, module_params):
+        validate_chain(module_params['chain'])
+        validate_amount_interval(module_params['amount'])
+
+        return module_params['chain'], module_params['amount'], module_params['token']