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

web3_wizzard_lib/core/contract/yoddlo_contract.py

@@ -0,0 +1,19 @@
+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/yoddlo.json")
+
+
+class YoddloContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def purchase(self, account):
+        txn_params = self.build_generic_data(account.address, True)
+
+        txn_params['value'] = 100000000000000
+        txn_params['data'] = '0xfb89f3b1'
+
+        return txn_params

web3_wizzard_lib/core/contract/yuliverse_contract.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/yoddlo.json")
+
+
+class YuliverseContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def purchase(self, account):
+        txn_params = self.build_generic_data(account.address, True)
+
+        function_selector = "0x064a181e"
+
+        # Example uint256 paramet er
+        varg0 = 123456789  # Make sure this is the value you intend to use
+
+        # Example bytes parameter (signature) - Ensure this is exactly 65 bytes
+        varg1 = b'Your65ByteSignatureHere'  # This should be the actual signature bytes
+
+        # Encoding the transaction data
+        data = function_selector
+        data += varg0.to_bytes(32, byteorder='big').hex()
+        data += (32).to_bytes(32, byteorder='big').hex()  # Offset for dynamic data
+        data += (65).to_bytes(32, byteorder='big').hex()  # Length of the signature
+        data += varg1.hex()
+
+        print(data)
+
+        # Concatenate the selector and the encoded parameters
+        txn_params['data'] = data
+
+        return txn_params

web3_wizzard_lib/core/contract/zebra_contract.py

@@ -0,0 +1,68 @@
+import time
+
+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
+from web3 import Web3
+
+abi = load_abi("resources/abi/zebra.json")
+
+
+class ZebraContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def get_min_amount_out(self, amount, from_token: str, to_token: str):
+        min_amount_out = self.contract.functions.getAmountsOut(
+            amount.wei,
+            [
+                Web3.to_checksum_address(from_token),
+                Web3.to_checksum_address(to_token)
+            ]
+        ).call()
+        return min_amount_out[1]
+
+    @evm_transaction
+    def swap_to_token(self, account, amount, from_token: str, to_token: str, min_amount_out: int):
+        tx_data = self.build_generic_data(
+            account.address,
+            False
+        )
+
+        tx_data['value'] = amount.wei
+
+        deadline = int(time.time()) + 1000000
+
+        contract_txn = self.contract.functions.swapExactETHForTokens(
+            min_amount_out,
+            [
+                from_token,
+                to_token,
+            ],
+            account.address,
+            deadline
+        ).build_transaction(tx_data)
+
+        return contract_txn
+
+    @evm_transaction
+    def swap_to_eth(self, account, amount, from_token: str, to_token: str, min_amount_out: int):
+        tx_data = self.build_generic_data(
+            account.address,
+            False
+        )
+
+        deadline = int(time.time()) + 1000000
+
+        contract_txn = self.contract.functions.swapExactTokensForETH(
+            amount.wei,
+            min_amount_out,
+            [
+                from_token,
+                to_token,
+            ],
+            account.address,
+            deadline
+        ).build_transaction(tx_data)
+
+        return contract_txn

web3_wizzard_lib/core/contract/zerolend_contract.py

@@ -0,0 +1,34 @@
+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/zerolend.json")
+
+
+class ZeroLendContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def deposit_eth(self, account, amount):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, False)
+
+        txn_params['value'] = amount
+
+        return self.contract.functions.depositETH(
+            '0x2f9bB73a8e98793e26Cb2F6C4ad037BDf1C6B269',
+            account.address,
+            0
+        ).build_transaction(txn_params)
+
+    @evm_transaction
+    def withdraw_eth(self, account, amount):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, False)
+
+        return self.contract.functions.withdrawETH(
+            '0x2f9bB73a8e98793e26Cb2F6C4ad037BDf1C6B269',
+            int(amount * 0.98),
+            account.address
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/zerolend_liq_contract.py

@@ -0,0 +1,20 @@
+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/zerolend_liquidity.json")
+
+class ZeroLendLiqContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def create_lock(self, account, amount):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, False)
+
+        return self.contract.functions.createLock(
+            int(amount.wei * 0.99),
+            31536000,
+            True
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/zkdx_contract.py

@@ -0,0 +1,40 @@
+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/woofi.json")
+
+
+class ZKDXContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+        self.zkdx_token = '176211869ca2b568f2a7d4ee941e073a821ee1ff'
+
+    @evm_transaction
+    def swap_to_zkdx(self, account, amount):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, True)
+
+        amount_hex = self.decimal_to_hex_padded(amount.wei)
+        txn_params[
+            'data'] = f'0x045d0389000000000000000000000000{self.zkdx_token}00000000000000000000000000000000{amount_hex}'
+
+        return txn_params
+
+    @evm_transaction
+    def swap_from_zkdx(self, account, amount):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, True)
+
+        amount_hex = self.decimal_to_hex_padded(amount)
+
+        # txn_params['gas'] = 60000
+
+        txn_params[
+            'data'] = f'0x1e9a6950000000000000000000000000{self.zkdx_token}00000000000000000000000000000000{amount_hex}'
+
+        return txn_params
+
+    def decimal_to_hex_padded(self, decimal_number):
+        hex_number = hex(decimal_number)[2:]  # Remove the '0x' prefix
+        return hex_number.zfill(32)  # Pad with zeros to make the length 32

web3_wizzard_lib/core/contract/zkdx_data.py

@@ -0,0 +1,14 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/zkdx_data.json")
+
+
+class ZKDXDataContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+        # self.zkdx_token = '0x176211869cA2b568f2A7D4EE941E073a821EE1ff'
+        self.zkdx_token = '0x2167C4D5FE05A1250588F0B8AA83A599e7732eae'
+
+    def get_balance(self, account):
+        return self.contract.functions.getTokenBalances(account.address, [self.zkdx_token]).call()

web3_wizzard_lib/core/contract/zks.py

@@ -0,0 +1,24 @@
+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/zks.json")
+
+
+class ZKS(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def register(self, account, domain_name):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+
+        contract_txn = self.contract.functions.register(domain_name, sender, 1).build_transaction(txn_params)
+        contract_txn['gas'] = self.web3.eth.estimate_gas(contract_txn)
+
+        return contract_txn
+
+    def available(self, domain_name):
+        return self.contract.functions.available(domain_name).call()

web3_wizzard_lib/core/modules/ads_import_proxy.py

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

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

@@ -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.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

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

@@ -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.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

@@ -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.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

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

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