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

web3_wizzard_lib/core/modules/ads_import_proxy.py

@@ -1,52 +0,0 @@
-from urllib.parse import urlparse
-
-from loguru import logger
-from sybil_engine.module.module import Module
-import requests
-
-
-class AdsImportProxy(Module):
-    module_name = 'ADS_IMPORT_PROXY'
-    module_config = 'ads_import_config'
-
-    def execute(self, ads_url, account):
-        parsed_proxy = urlparse(account.proxy)
-        proxy_type = parsed_proxy.scheme
-        proxy_host = parsed_proxy.hostname
-        proxy_port = parsed_proxy.port
-        proxy_user = parsed_proxy.username
-        proxy_password = parsed_proxy.password
-
-        logger.info(f"Import proxy {account.proxy} for account {account.app_id}")
-
-        response = requests.get(f"{ads_url}/list", params={"serial_number": str(account.app_id)})
-        user_id = response.json()['data']['list'][0]["user_id"]
-
-        self.updateProfile(ads_url, user_id, proxy_host, proxy_password, proxy_port, proxy_type, proxy_user)
-
-    def updateProfile(self, ads_url, user_id, proxy_host, proxy_password, proxy_port, proxy_type, proxy_user):
-        data = {
-            "user_id": user_id,
-            "user_proxy_config": {
-                "proxy_type": proxy_type,
-                "proxy_host": proxy_host,
-                "proxy_port": str(proxy_port),
-                "proxy_user": proxy_user,
-                "proxy_password": proxy_password,
-                "proxy_soft": "luminati"
-            }
-        }
-        response = requests.post(f"{ads_url}/update", json=data)
-        logger.info(response.status_code)
-        logger.info(response.json())
-
-    def log(self):
-        return "ADS IMPORT PROXY"
-
-    def parse_params(self, module_params):
-        if 'ads_url' not in module_params:
-            module_params['ads_url'] = "http://local.adspower.net:50325/api/v1/user"
-
-        return [
-            module_params['ads_url']
-        ]

web3_wizzard_lib/core/modules/airdrop_printer.py

@@ -1,81 +0,0 @@
-import requests
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.module.module import Module
-from web3 import Web3
-
-from web3_wizzard_lib.core.utils.statistic_utils import get_statistic_writer, statistic_date_string
-
-
-class AirdropPrinter(Module):
-    module_name = 'AIRDROP_PRINTER'
-    module_config = None
-
-    claimers = {
-        "L0": "0xB09F16F625B363875e39ADa56C03682088471523",
-        "SCROLL": "0xE8bE8eB940c0ca3BD19D911CD3bEBc97Bea0ED62",
-        "ZKSYNC": "0x66Fd4FC8FA52c9bec2AbA368047A0b27e24ecfe4",
-        "ORBITER": "0x13dFDd3a9B39323F228Daf73B62C23F7017E4679",
-        "ODOS": "0x4C8f8055D88705f52c9994969DDe61AB574895a3"
-    }
-
-    EMPTY_ADDRESS = '-'
-
-    chains = ["ARBITRUM", "ZKSYNC", "SCROLL", "BASE"]
-
-    def execute(self, account, statistic_write='GOOGLE'):
-        chain_contracts = {}
-        for chain in self.chains:
-            chain_instance = get_chain_instance(chain)
-
-            datas = self.find_interacted_contracts_hash(
-                account.address,
-                chain_instance['api_scan'],
-                chain_instance['api_scan_key']
-            )
-
-            chain_contracts[chain] = datas['result']
-
-        account_links = {}
-
-        for project, claim_address in self.claimers.items():
-            for chain, datas in chain_contracts.items():
-                chain_instance = get_chain_instance(chain)
-                for data in datas:
-                    if data['to'] != "" and claim_address == Web3.to_checksum_address(data['to']):
-                        account_links[project] = chain_instance['scan'] + "tx/" + data['hash']
-
-            if account_links.get(project) is None:
-                account_links[project] = self.EMPTY_ADDRESS
-
-        logger.info(account_links)
-        statistics_writer = get_statistic_writer()
-        job_name = f"airdrops_{statistic_date_string}"
-        statistics_writer.init_if_required(job_name, ['#', 'Address'] + list(self.claimers.keys()))
-
-        value_row = [account.app_id, account.address]
-        for project, address in account_links.items():
-            value_row.append(address)
-
-        statistics_writer.write_row(job_name, value_row)
-
-    def find_interacted_contracts_hash(self, wallet_address, api_url, api_key):
-        api_url = f"{api_url}/api?module=account&action=txlist&address={wallet_address}&startblock=0&endblock=latest&sort=asc&apikey={api_key}&offset=200"
-
-        if "base" in api_url:
-            logger.info(f"BASE {api_url}")
-            pass
-
-        response = requests.get(api_url)
-        data = response.json()
-
-        if data['status'] == '1' and data['message'] == 'OK':
-            return data
-        else:
-            logger.info("nothing")
-            logger.info(data)
-            pass
-            return data
-
-    def log(self):
-        return "AIRDROP PRINTER"

web3_wizzard_lib/core/modules/bank/aave.py

@@ -1,25 +0,0 @@
-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.aavecontract import AaveContract
-from web3_wizzard_lib.core.modules.bank.bank import Bank
-
-
-class Aave(Bank):
-    app_name = 'AAVE'
-    supported_chains = ['SCROLL']
-
-    def __init__(self, contract, web3):
-        self.contract = AaveContract(contract, web3)
-
-    def supply(self, account, amount):
-        self.contract.depositETH(account, amount.wei)
-
-    def redeem(self, account, withdraw):
-        self.contract.withdrawETH(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])['AAVE_WETH']
-
-        return WETH(weth_token, self.contract.web3).balance_of(account)

web3_wizzard_lib/core/modules/bank/bank.py

@@ -1,15 +0,0 @@
-class Bank:
-    def supply(self, account, amount):
-        pass
-
-    def borrow(self, account, amount):
-        pass
-
-    def repay_borrow(self, account, amount):
-        pass
-
-    def redeem(self, account, amount, token):
-        pass
-
-    def get_deposit_amount(self, account, token):
-        pass

web3_wizzard_lib/core/modules/bank/basilisk.py

@@ -1,25 +0,0 @@
-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.basiliskcontract import BasiliskContract
-from web3_wizzard_lib.core.modules.bank.bank import Bank
-
-
-class Basilisk(Bank):
-    app_name = 'BASILISK_LANDING'
-    supported_chains = ['ZKSYNC']
-
-    def __init__(self, contract, web3):
-        self.contract = BasiliskContract(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])['BASILISK_LANDING']
-
-        return WETH(weth_token, self.contract.web3).balance_of(account)

web3_wizzard_lib/core/modules/bank/eralend.py

@@ -1,25 +0,0 @@
-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.eralendcontract import EraLendContract
-from web3_wizzard_lib.core.modules.bank.bank import Bank
-
-
-class Eralend(Bank):
-    app_name = 'ERALEND'
-    supported_chains = ['ZKSYNC']
-
-    def __init__(self, contract, web3):
-        self.contract = EraLendContract(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])['ERALEND']
-
-        return WETH(weth_token, self.contract.web3).balance_of(account)

web3_wizzard_lib/core/modules/bank/layerbank.py

@@ -1,116 +0,0 @@
-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.layerbank_price import LayerBankPrice
-from web3_wizzard_lib.core.contract.layerbank_token import LayerBankToken
-from web3_wizzard_lib.core.contract.layerbankcontract import LayerBankContract
-from web3_wizzard_lib.core.modules.bank.bank import Bank
-
-
-class LayerBank(Bank):
-    app_name = 'LAYERBANK'
-    supported_chains = ['LINEA']
-
-    def __init__(self, chain, web3):
-        self.chain = chain
-        self.web3 = web3
-        self.layerbank = LayerBankContract(get_contracts_for_chain(chain)["LAYERBANK"], web3)
-
-        lbwstETH = get_tokens_for_chain(chain)['lbwstETH']
-        self.lbWstETHToken = LayerBankToken(lbwstETH, web3)
-
-        lbETH = get_tokens_for_chain(chain)['lbETH']
-        self.lbETHToken = LayerBankToken(lbETH, web3)
-
-    def supply(self, account, token):
-        token = LayerBankToken(get_tokens_for_chain(self.chain)[token], self.web3)
-
-        erc20_token = Erc20Token(self.chain, token, self.web3)
-        amount = erc20_token.balance(account)
-
-        if 25 * token.one_decimal() <= self.layerbank.account_liquidity_of(account)[0]:
-            logger.info("Already supplied over 25$ worth, skip this step")
-            return
-
-        if erc20_token.allowance(account, token.contract_address) < amount.wei:
-            erc20_token.approve(account, token.contract_address)
-
-        if amount.wei > 0:
-            if token.contract_address not in self.layerbank.market_list_of(account):
-                logger.info("Add support wstETH to LayerBank")
-                self.layerbank.enter_markets(account, token.contract_address)
-
-            logger.info(f"Supply {amount.log_line()}")
-
-            self.layerbank.supply(account, token.contract_address, amount.wei)
-
-        if 25 * token.one_decimal() > self.layerbank.account_liquidity_of(account)[0]:
-            raise Exception(
-                f"Not enough supply for 25$ borrow {self.layerbank.account_liquidity_of(account)[0] / token.one_decimal()}"
-            )
-
-    def borrow(self, account, token):
-        token = LayerBankToken(get_tokens_for_chain(self.chain)[token], self.web3)
-
-        layerbank_price = LayerBankPrice(get_contracts_for_chain(self.chain)["LAYERBANK_PRICE"], self.web3)
-
-        usd_collateral = self.layerbank.account_liquidity_of(account)[0]
-        eth_amount = (usd_collateral / layerbank_price.get_underlying_price(token.contract_address))
-
-        logger.info(f"Borrow {eth_amount} {token.symbol()}")
-
-        borrow_amount = int(
-            eth_amount * token.one_decimal() * token.one_decimal() / token.exchange_rate())
-
-        self.layerbank.borrow(
-            account,
-            token.contract_address,
-            borrow_amount
-        )
-
-    def repay_borrow(self, account, token):
-        token = LayerBankToken(get_tokens_for_chain(self.chain)[token], self.web3)
-
-        layerbank_price = LayerBankPrice(get_contracts_for_chain(self.chain)["LAYERBANK_PRICE"], self.web3)
-
-        borrowed_usdc = self.layerbank.account_liquidity_of(account)[2]
-        lbETHPrice = layerbank_price.get_underlying_price(token.contract_address)
-        ethAmount = int(
-            (
-                    borrowed_usdc / lbETHPrice) * token.one_decimal() * token.one_decimal() / token.exchange_rate()
-        )
-
-        if 2 * token.one_decimal() > borrowed_usdc:
-            logger.info("Less than 2$ borrowed, skip")
-            return
-
-        logger.info(f"Repay Borrow {ethAmount / token.one_decimal()}")
-        self.layerbank.repay_borrow(account, token.contract_address, ethAmount)
-
-    def redeem(self, account, amount, token):
-        if token == 'ETH':
-            token = self.lbETHToken
-        elif token == 'wstETH':
-            token = self.lbWstETHToken
-
-        underlying_balance = self.get_deposit_amount(account, token)
-
-        if underlying_balance < 10000:
-            logger.info("Less than 0.001$ supplied, skip")
-            return
-
-        self.layerbank.redeem_token(
-            account,
-            token.contract_address,
-            int(underlying_balance * token.one_decimal() * 0.999 / token.exchange_rate())
-        )
-
-    def get_deposit_amount(self, account, token):
-        if token == 'ETH':
-            token = self.lbETHToken
-        elif token == 'wstETH':
-            token = self.lbWstETHToken
-
-        return token.underlying_balance_of(account)

web3_wizzard_lib/core/modules/bank/mendi_finance.py

@@ -1,57 +0,0 @@
-from loguru import logger
-from sybil_engine.data.tokens import get_tokens_for_chain
-from sybil_engine.domain.balance.tokens import Erc20Token
-
-from web3_wizzard_lib.core.contract.mendi_token import MendiTokenContract
-from web3_wizzard_lib.core.modules.bank.bank import Bank
-
-
-class MendiFinance(Bank):
-    app_name = 'MENDI_FINANCE'
-    supported_chains = ['LINEA']
-
-    def __init__(self, chain, web3):
-        self.chain = chain
-        self.web3 = web3
-
-    def supply(self, account, amount):
-        erc20 = Erc20Token(self.chain, amount.token, self.web3)
-        amount = erc20.balance(account)
-
-        me_token = f'me{amount.token}'
-        mendi_token_address = get_tokens_for_chain(self.chain)[me_token]
-
-        logger.info(f"Mendi supply {amount} {amount.token}")
-
-        if erc20.allowance(account, mendi_token_address) < erc20.balance(account).wei:
-            erc20.approve(account, mendi_token_address)
-
-        mendi = MendiTokenContract(mendi_token_address, self.web3)
-        mendi.mint(account, amount.wei)
-
-    def borrow(self, account, amount):
-        logger.info(f"Mendi borrow {amount.token}")
-
-    def repay_borrow(self, account, amount):
-        logger.info(f"Mendi repay {amount.token}")
-
-    def redeem(self, account, amount):
-        me_token = f'me{amount.token}'
-        mendi_token_address = get_tokens_for_chain(self.chain)[me_token]
-        mendi = MendiTokenContract(mendi_token_address, self.web3)
-
-        redeem_balance = mendi.balance_of(account)
-
-        if redeem_balance > 1000000000:
-            logger.info(f"Mendi reedem {amount. token}")
-            mendi.redeem(account, redeem_balance)
-        else:
-            logger.info(f"Mendi balance is 0")
-
-    def get_deposit_amount(self, account, token):
-        #me_token = f'meweETH'
-        mendi_token_address = get_tokens_for_chain(self.chain)[token]
-        mendi = MendiTokenContract(mendi_token_address, self.web3)
-
-        return mendi.balance_of(account)
-

web3_wizzard_lib/core/modules/bank/reactorfusion.py

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

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

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

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

web3_wizzard_lib/core/modules/bridge/coredao_bridge_sub.py

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