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

web3_wizzard_lib/core/modules/cex_subaccount_transfer.py

@@ -0,0 +1,34 @@
+from sybil_engine.config.app_config import get_cex_data, get_cex_conf
+from sybil_engine.domain.cex.binance import Binance
+from sybil_engine.domain.cex.okx import OKX
+from sybil_engine.module.module import Module
+from sybil_engine.utils.app_account_utils import AppAccount
+from sybil_engine.utils.utils import ConfigurationException
+
+
+class CEXSubAccountTransfer(Module):
+    module_name = 'CEX_SUB_ACCOUNT_TRANSFER'
+    module_config = 'cex_account_transfer_config'
+
+    def execute(self, cex, account: AppAccount):
+        password, cex_data = get_cex_data()
+
+        tokens = ['ETH', 'CORE', 'POL', 'USDC', 'USDT', 'OKB', 'ZRO']
+
+        if cex == 'okx':
+            cex_obj = OKX(cex_data[get_cex_conf()], password)
+        elif cex == 'binance':
+            cex_obj = Binance(cex_data[get_cex_conf()], password)
+        else:
+            raise ConfigurationException(f"{cex} is not")
+
+        cex_obj.transfer_from_sub_account(tokens)
+
+    def log(self):
+        return "CEX SUB ACCOUNT TRANSFER"
+
+    def parse_params(self, module_params):
+        if 'cex' not in module_params:
+            module_params['cex'] = 'okx'
+
+        return [module_params['cex']]

web3_wizzard_lib/core/modules/cex_withdraw.py

@@ -0,0 +1,91 @@
+import random
+
+from loguru import logger
+from sybil_engine.config.app_config import get_cex_data, get_cex_conf
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance_utils import get_native_balance, \
+    interval_to_native_balance, interval_to_erc20_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.domain.cex.binance import Binance
+from sybil_engine.domain.cex.okx import OKX
+from sybil_engine.module.module import Module
+from sybil_engine.utils.app_account_utils import AppAccount
+from sybil_engine.utils.utils import randomized_sleeping, ConfigurationException
+from sybil_engine.utils.web3_utils import init_web3
+
+
+class CEXWithdraw(Module):
+    module_name = 'CEX_WITHDRAW'
+    sleep_after_conf = True
+    module_config = 'cex_withdraw'
+
+    def execute(self, chain, withdraw_interval, min_auto_withdraw_interval, token, cex, account: AppAccount):
+        self.sleep_after_conf = True
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, None)
+
+        balance, min_auto_withdraw, withdraw_token = self.balance(account, chain, chain_instance,
+                                                                  min_auto_withdraw_interval, token, web3)
+        logger.info(f"{chain}")
+        logger.info(f"Minimum balance should be {min_auto_withdraw}")
+
+        if min_auto_withdraw.wei < balance.wei:
+            self.sleep_after_conf = False
+
+        while min_auto_withdraw.wei > balance.wei:
+            logger.info(f"Actual balance: {balance}")
+
+            amount = round(random.uniform(withdraw_interval['from'], withdraw_interval['to']), 6)
+            logger.info(f"Withdraw {amount} {chain_instance['gas_token']} from {cex} to {account.address}")
+
+            password, cex_data = get_cex_data()
+
+            if cex == 'okx':
+                cex_obj = OKX(cex_data[get_cex_conf()], password)
+            elif cex == 'binance':
+                cex_obj = Binance(cex_data[get_cex_conf()], password)
+            else:
+                raise ConfigurationException(f"{cex} is not")
+
+            if withdraw_token == 'WETH':
+                withdraw_token = 'ETH'
+
+            cex_obj.withdrawal(account.address, chain, amount, withdraw_token)
+
+            randomized_sleeping({'from': 60 * 2, 'to': 60 * 4})
+
+            balance, _, _ = self.balance(account, chain, chain_instance, min_auto_withdraw_interval, token, web3)
+
+    def balance(self, account, chain, chain_instance, min_auto_withdraw_interval, token, web3):
+        if token == 'NATIVE':
+            min_auto_withdraw = interval_to_native_balance(min_auto_withdraw_interval, account, chain, web3)
+            balance = get_native_balance(account, web3, chain_instance)
+            withdraw_token = chain_instance['gas_token']
+        elif token in ['USDC', 'USDT', 'WETH', 'ETH']:
+            if token == 'ETH':
+                token = 'WETH'
+            min_auto_withdraw = interval_to_erc20_balance(min_auto_withdraw_interval, account, token, chain, web3)
+            erc20_token = Erc20Token(chain, token, web3)
+            balance = erc20_token.balance(account)
+            withdraw_token = token
+        else:
+            raise ConfigurationException(f"Unsupported token {token}, supported tokens are: NATIVE, USDC")
+        return balance, min_auto_withdraw, withdraw_token
+
+    def log(self):
+        return "CEX WITHDRAW"
+
+    def parse_params(self, module_params):
+        if 'cex' not in module_params:
+            module_params['cex'] = 'okx'
+
+        return [
+            module_params['chain'],
+            module_params['withdraw_interval'],
+            module_params['min_auto_withdraw_interval'],
+            module_params['token'],
+            module_params['cex']
+        ]
+
+    def sleep_after(self):
+        return self.sleep_after_conf

web3_wizzard_lib/core/modules/claimer.py

@@ -0,0 +1,45 @@
+from loguru import logger
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.module.module import Module
+from sybil_engine.utils.app_account_utils import AppAccount
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.modules.claims.layerzero_claimer import claimer_zro
+from web3_wizzard_lib.core.modules.claims.rabby_claimer import claimer_rabby
+
+native_prices = {
+    'ETH': 3700,
+    'USDT': 1
+}
+
+
+class Claimer(Module):
+    module_name = 'CLAIMER'
+    sleep_after_conf = True
+    module_config = 'claimer_config'
+
+    def execute(self, chain, layerzero_token, project, account: AppAccount):
+        logger.info(f"CLAIM L0 tokens for {account} on {chain}")
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, None)
+
+        if project == 'ZRO':
+            claimer_zro(account, chain_instance, layerzero_token, web3)
+        else:
+            claimer_rabby(account, web3)
+
+    def log(self):
+        return "CLAIMER"
+
+    def parse_params(self, module_params):
+        if 'project' not in module_params:
+            module_params['project'] = 'ZRO'
+
+        return [
+            module_params['chain'],
+            module_params['token'],
+            module_params['project']
+        ]
+
+    def sleep_after(self):
+        return self.sleep_after_conf

web3_wizzard_lib/core/modules/claims/layerzero_claimer.py

@@ -0,0 +1,64 @@
+import requests
+from loguru import logger
+from sybil_engine.config.app_config import get_cex_conf, get_cex_data
+from sybil_engine.domain.balance.balance import NativeBalance, Erc20Balance
+from sybil_engine.domain.balance.balance_utils import get_native_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.domain.cex.okx import OKX
+
+total_zro = 0
+
+def claimer_zro(account, chain_instance, token, web3):
+    allocation_data = get_allocation(account.address)
+    if not allocation_data:
+        raise Exception("Failed to fetch allocation data.")
+    amount_raw = int(allocation_data.get('zroAllocation', {}).get('asBigInt'))
+    logger.info(f"ZRO Allocation for {account.address} is {amount_raw}")
+    if token == 'NATIVE':
+        withdraw_token = chain_instance['gas_token']
+        claim_price = NativeBalance(int((round(amount_raw / 10 ** 18) + 1) * 0.00005 * 10 ** 18),
+                                    chain_instance['chain'], token)
+        balance = get_native_balance(account, web3, chain_instance)
+        logger.info(f"Native balance is {balance}")
+    else:
+        claim_price = Erc20Balance(
+            int((round(amount_raw / 10 ** 18) + 1) * 0.00003 * 10 ** 18),
+            chain_instance['chain'],
+            token,
+            decimal=18
+        )
+        withdraw_token = token
+        balance = Erc20Token(chain_instance['chain'], token, web3).balance(account)
+        logger.info(f"Native balance is {balance}")
+    logger.info(f"Need {claim_price} for claim")
+    if claim_price.wei > balance.wei:
+        password, cex_data = get_cex_data()
+        cex_obj = OKX(cex_data[get_cex_conf()], password)
+        cex_obj.withdrawal(account.address, chain_instance['chain'], float(balance.readable()), withdraw_token)
+
+    proof = get_proof(account.address)
+    logger.info(proof)
+    global total_zro
+    total_zro = total_zro + int(proof['amount'])
+    amount_to_claim = int(proof['amount'])
+    merkle_proof = proof['proof'].split('|')
+    #contract_address = get_contracts_for_chain(chain_instance['chain'])['ZRO_CLAIMER']
+    #claimer = L0Claim(contract_address, web3)
+    #claimer.donateAndClaim(account, claim_price.wei, amount_to_claim, merkle_proof)
+
+def get_proof(wallet):
+    url = f"https://www.layerzero.foundation/api/proof/{wallet}?address={wallet}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        return response.json()
+    else:
+        return None
+
+
+def get_allocation(wallet):
+    url = f"https://www.layerzero.foundation/api/allocation/{wallet}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        return response.json()
+    else:
+        return None

web3_wizzard_lib/core/modules/claims/rabby_claimer.py

@@ -0,0 +1,81 @@
+import time
+from random import randint
+
+from eth_account.messages import encode_defunct, SignableMessage
+from fake_useragent import UserAgent
+from loguru import logger
+
+import requests
+from sybil_engine.utils.utils import randomized_sleeping
+
+url = "https://api.rabby.io/v2/points/claim_snapshot"
+
+headers = {
+    "Host": "api.rabby.io",
+    "Connection": "keep-alive",
+    "Content-Length": "224",
+    "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+    "X-Version": "0.92.48",
+    "sec-ch-ua-mobile": "?0",
+    "User-Agent": UserAgent().random,
+    "x-api-ts": str(int(time.time())),
+    "Content-Type": "application/json",
+    "x-api-ver": "v2",
+    "Accept": "application/json, text/plain, */*",
+    "X-Client": "Rabby",
+    "sec-ch-ua-platform": '"Windows"',
+    "Origin": "chrome-extension://acmacodkjb dgmoleebolmdjonilkdbch",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Dest": "empty",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Accept-Language": "uk-UA,uk;q=0.9,en-US;q=0.8,en;q=0.7",
+}
+
+
+def claimer_rabby(account, web3):
+    try:
+        address = account.address.lower()
+        msg = f"{address} Claims Rabby Points"
+
+        payload = {
+            "id": address,
+            "signature": get_signed_code(web3, account, msg),
+            "invite_code": "FREEBONUS"
+        }
+
+        proxies = {}
+        proxies.update(
+            {"http": account.proxy,
+            "https": account.proxy}
+        )
+
+        response = make_request_with_retries(url, headers=headers, json=payload, proxies=proxies)
+
+        if response.json().get("error_code") == 0:
+            logger.success(f"{address} | Claimed!")
+        else:
+            resp_msg = response.json().get("error_msg")
+            logger.info(f"{address} | {resp_msg} | {response.json()}")
+    except Exception as e:
+        logger.error(f"{account}... | {e}")
+
+
+def sign(web3, account, encoded_msg: SignableMessage):
+    return web3.eth.account.sign_message(encoded_msg, account.key)
+
+
+def get_signed_code(web3, account, msg) -> str:
+    return sign(web3, account, encode_defunct(text=msg)).signature.hex()
+
+def make_request_with_retries(url, headers, json, proxies, max_retries=5):
+    for attempt in range(max_retries):
+        response = requests.post(url, headers=headers, json=json, proxies=proxies)
+        if response.status_code == 429:
+            retry_after = int(response.headers.get("Retry-After", randint(1, 5)))
+            logger.info(f"Rate limited. Retrying after {retry_after} seconds. Attempt {attempt + 1}/{max_retries}")
+            time.sleep(retry_after)
+        else:
+            return response
+    logger.error("Max retries reached. Giving up.")
+    return None

web3_wizzard_lib/core/modules/concrete_swap.py

@@ -0,0 +1,108 @@
+import random
+
+from loguru import logger
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance_utils import verify_balance, amount_to_swap_from_interval
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.module.module import Module
+from sybil_engine.utils.utils import SwapException
+from sybil_engine.utils.validation_utils import validate_amount_interval, validate_token
+from sybil_engine.utils.web3_utils import init_web3
+from web3 import Web3
+
+from web3_wizzard_lib.core.modules.swap.swap_list import swap_facade
+
+
+class ConcreteSwap(Module):
+    module_name = 'CONCRETE_SWAP'
+    module_config = 'swap_config'
+    allowed_chains = ['ZKSYNC', 'LINEA', 'BASE', 'SCROLL', 'ARBITRUM']
+    sleep_after_var = True
+
+    def execute(self, chain, amount_interval, from_token, to_token, swap_app, account):
+        if isinstance(swap_app, list):
+            swap_app = random.choice(swap_app)
+
+        self.sleep_after_var = True
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        native_balance = verify_balance(self.min_native_balance, chain_instance, account, web3)
+
+        from_token_contract = Erc20Token(chain, from_token, web3)
+        to_token_contract = Erc20Token(chain, to_token, web3)
+
+        if Web3.is_address(from_token):
+            from_token_symbol = from_token_contract.symbol()
+        else:
+            from_token_symbol = from_token
+
+        if Web3.is_address(to_token):
+            to_token_symbol = to_token_contract.symbol()
+        else:
+            to_token_symbol = to_token
+
+        pair_to_swap = self.create_pair_to_swap(
+            from_token_symbol,
+            swap_app,
+            to_token_symbol,
+        )
+
+        amount_to_swap = amount_to_swap_from_interval(
+            account,
+            chain,
+            self.min_native_balance,
+            native_balance,
+            amount_interval,
+            from_token,
+            web3
+        )
+
+        if amount_to_swap.wei < 100000:
+            logger.info("Low balance, ignore")
+            return
+
+        try:
+            swap_facade.swap(
+                account,
+                amount_to_swap,
+                chain_instance,
+                pair_to_swap,
+                swap_app,
+                from_token,
+                to_token,
+                web3
+            )
+        except SwapException as e:
+            logger.info(e.message)
+            self.sleep_after_var = False
+
+    def create_pair_to_swap(self, from_token, swap_app, to_token):
+        pair_to_swap = {
+            'name': f'{from_token}>{to_token}',
+            'tokens': [from_token, to_token],
+            'slippage': 2,
+            'app': swap_app
+        }
+        return pair_to_swap
+
+    def log(self):
+        return "SWAP"
+
+    def sleep_after(self):
+        return self.sleep_after_var
+
+    def parse_params(self, module_params):
+        self.validate_supported_chain(module_params['chain'])
+        validate_amount_interval(module_params['amount_interval'])
+        validate_token(module_params['from_token'])
+        validate_token(module_params['to_token'])
+        #validate_dex(module_params['app'])
+
+        return (
+            module_params['chain'],
+            module_params['amount_interval'],
+            module_params['from_token'],
+            module_params['to_token'],
+            module_params['app']
+        )

web3_wizzard_lib/core/modules/coredao_bridge.py

@@ -0,0 +1,32 @@
+from sybil_engine.module.module import Order, Module
+
+from web3_wizzard_lib.core.modules.bridge.coredao_bridge_sub import CoreDaoBridgeSubModule
+
+
+class CoreDaoBridge(Module):
+    module_name = 'COREDAO_BRIDGE'
+    allowed_chains = ['POLYGON', 'COREDAO']
+    module_config = 'coredao_bridge_config'
+
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, account):
+        CoreDaoBridgeSubModule().execute(
+            bridge_amount_interval,
+            from_chain,
+            to_chain,
+            token,
+            self.min_native_balance,
+            account
+        )
+
+    def log(self):
+        return "COREDAO BRIDGE"
+
+    def parse_params(self, module_params):
+        self.validate_supported_chain(module_params['from_chain'])
+        self.validate_supported_chain(module_params['to_chain'])
+
+        return module_params['bridge_amount_interval'], module_params['from_chain'], module_params['to_chain'], \
+            module_params['token']
+
+    def order(self):
+        return Order.RANDOM

web3_wizzard_lib/core/modules/coredao_bridge_auto.py

@@ -0,0 +1,39 @@
+from sybil_engine.module.module import Order, RepeatableModule
+from sybil_engine.utils.utils import interval_to_int, randomized_sleeping
+
+from web3_wizzard_lib.core.modules.bridge.coredao_bridge_sub import CoreDaoBridgeSubModule
+
+
+class CoreDaoBridgeAuto(RepeatableModule):
+    module_name = 'COREDAO_BRIDGE_AUTO'
+    allowed_chains = ['POLYGON', 'COREDAO']
+    random_order = Order.RANDOM
+    repeat_conf = 'repeats'
+    module_config = 'coredao_bridge_auto_config'
+
+    @RepeatableModule.repeatable_log
+    def execute(self, from_chain, to_chain, bridge_amount_interval, token, sleep_interval, account):
+        CoreDaoBridgeSubModule().execute(bridge_amount_interval, from_chain, to_chain, token, account)
+        randomized_sleeping(sleep_interval)
+        CoreDaoBridgeSubModule().execute(bridge_amount_interval, to_chain, from_chain, token, account)
+
+    def log(self):
+        return "COREDAO BRIDGE AUTO"
+
+    def parse_params(self, module_params):
+        return [
+            module_params['from_chain'],
+            module_params['to_chain'],
+            module_params['bridge_amount_interval'],
+            module_params['token'],
+            module_params['sleep_interval'],
+        ]
+
+    def order(self):
+        return Order.RANDOM
+
+    def repeats(self, module_params):
+        if self.repeat_conf not in module_params:
+            return 1
+        else:
+            return range(interval_to_int(module_params[self.repeat_conf]))

web3_wizzard_lib/core/modules/debank_checker.py

@@ -0,0 +1,78 @@
+from sybil_engine.module.module import Module
+from sybil_engine.utils.accumulator import add_accumulator, get_value
+
+from web3_wizzard_lib.core.utils.statistic_utils import statistic_date_string, get_statistic_writer
+from web3_wizzard_lib.utils.debank_utils import debank_request
+
+TOTAL_USD = "TotalUSD"
+DEBANK_ACC_NUM = "DEBANK_ACC_NUM"
+
+
+class DebankChecker(Module):
+    module_name = "DEBANK_CHECKER"
+    module_config = None
+
+    cumulative_chain_sums = {}
+
+    supported_chains = [
+        'ethereum',
+        'arbitrum',
+        'op',
+        'zksync era',
+        'base',
+        'bnb Chain',
+        'linea',
+        'polygon',
+        'avalanche',
+        'scroll',
+        'utils',
+        'fantom',
+        'zora',
+        'arbitrum nova',
+        'celo',
+        'klaytn'
+    ]
+
+    def execute(self, account, statistic_write='GOOGLE'):
+        data = debank_request(account.address)
+
+        job_name = f"debank_{statistic_date_string}"
+        statistics_writer = get_statistic_writer()
+
+        add_accumulator(DEBANK_ACC_NUM, 1)
+
+        total_usd_value = data.get('total_usd_value', 0)
+        chain_list = data.get('chain_list', [])
+        chain_list = [item for item in chain_list if item['name'].lower() in self.supported_chains]
+        chain_list = sorted(chain_list, key=lambda x: x['community_id'])
+
+        chain_names = [chain.get('name') for chain in chain_list]
+
+        statistics_writer.init_if_required(
+            job_name,
+            ['ADS ID', 'Wallet ID', 'Total USD Value'] + chain_names
+        )
+
+        row = [account.app_id, account.address, total_usd_value]
+        for chain in chain_list:
+            usd_value = chain.get('usd_value', 0)
+            row.append(usd_value)
+
+            if chain['name'] in self.cumulative_chain_sums:
+                self.cumulative_chain_sums[chain['name']] += usd_value
+            else:
+                self.cumulative_chain_sums[chain['name']] = usd_value
+
+        statistics_writer.write_row(job_name, row)
+
+        add_accumulator(TOTAL_USD, total_usd_value)
+
+        if get_value(DEBANK_ACC_NUM) == get_value("Acc Amount"):
+            cumulative_row = ['SUM', '', get_value(TOTAL_USD)]
+            for chain_name in chain_names:
+                cumulative_row.append(self.cumulative_chain_sums.get(chain_name, 0))
+
+            statistics_writer.write_row(job_name, cumulative_row)
+
+    def log(self):
+        return "Debank Checker"

web3_wizzard_lib/core/modules/dmail.py

@@ -0,0 +1,54 @@
+import random
+from hashlib import sha256
+
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.module.module import Order, RepeatableModule
+from sybil_engine.utils.utils import interval_to_int
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.dmail_send_mail import DmailSend
+
+
+class Dmail(RepeatableModule):
+    module_name = 'DMAIL'
+    module_config = 'send_dmail_config'
+    allowed_chains = ['ZKSYNC', 'LINEA', 'SCROLL', 'MANTA', 'BASE']
+    random_order = Order.RANDOM
+    repeat_conf = 'email_amount'
+
+    @RepeatableModule.repeatable_log
+    def execute(self, chain, account):
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        dmail_contract_address = get_contracts_for_chain(chain)["DMAIL"]
+
+        email = sha256(str(1e11 * random.random()).encode()).hexdigest()
+        theme = sha256(str(1e11 * random.random()).encode()).hexdigest()
+
+        args = [account, email, theme]
+
+        dmail_sender = self.get_contract_class()(dmail_contract_address, web3)
+
+        dmail_sender.send_mail(*args)
+
+    def log(self):
+        return "SEND EMAIL"
+
+    def get_contract_class(self):
+        return DmailSend
+
+    def parse_params(self, module_params):
+        self.validate_supported_chain(module_params['chain'])
+
+        return (module_params['chain'],)
+
+    def order(self):
+        return Order.RANDOM
+
+    def repeats(self, module_params):
+        if self.repeat_conf not in module_params:
+            return 1
+        else:
+            return range(interval_to_int(module_params[self.repeat_conf]))

web3_wizzard_lib/core/modules/erc20_balance.py

@@ -0,0 +1,42 @@
+from loguru import logger
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.module.module import Order, Module
+from sybil_engine.utils.accumulator import add_accumulator_balance
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.dmail_send_mail import DmailSend
+
+
+class Erc20BalanceModule(Module):
+    module_name = 'ERC20_BALANCE_MODULE'
+    module_config = 'erc20_balance'
+    allowed_chains = ['ZKSYNC', 'LINEA', 'SCROLL', 'MANTA', 'BASE']
+    cumulative_sum = 0
+
+    def execute(self, token_address, chain, account):
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        erc20_token = Erc20Token('LINEA', token_address, web3)
+
+        balance = erc20_token.balance(account)
+
+        self.cumulative_sum = self.cumulative_sum + balance.wei
+
+        logger.info(f"{account.address} balance is {balance}")
+        add_accumulator_balance("Total balance is", balance.wei)
+
+    def log(self):
+        return "ERC20 BALANCE"
+
+    def get_contract_class(self):
+        return DmailSend
+
+    def parse_params(self, module_params):
+        self.validate_supported_chain(module_params['chain'])
+
+        return module_params['token_address'], module_params['chain']
+
+    def order(self):
+        return Order.RANDOM