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

web3_wizzard_lib/core/modules/linea_appeal.py

@@ -1,98 +0,0 @@
-import random
-import webbrowser
-
-from loguru import logger
-from sybil_engine.module.module import Module
-from sybil_engine.utils.accumulator import add_accumulator, get_value
-
-from web3_wizzard_lib.core.utils.ai_utils import get_ai_chat
-
-from web3_wizzard_lib.core.utils.module_memory import get_by_key, accumulate_by_key, remove_key, add_value
-from web3_wizzard_lib.core.utils.statistic_utils import get_statistic_writer, statistic_date_string
-
-APPEAL_ACCOUNTS = "APPEAL_ACCOUNTS"
-APPEAL_ACCOUNTS_AMOUNT = "APPEAL_ACCOUNTS_AMOUNT"
-
-
-class LineaAppeal(Module):
-    module_name = 'LINEA_APPEAL'
-    module_config = "linea_appeal_config"
-    base_url = "https://docs.google.com/forms/d/e/1FAIpQLSfkbHzC1hZTy6u5R8S5i6wQ2xCyUZQjvucmlyChwg04fJIO5Q/viewform"
-
-    def execute(self, token, accounts, statistic_write, ai_type, account):
-        with open("resources/linea_appeal.txt") as f:
-            self.linea_appeal_reason = f.read()
-
-        with open("resources/ai_style_randomized.txt") as f:
-            self.lines = f.readlines()
-
-        with open("resources/ai_reason_randomized.txt") as f:
-            self.reason_lines = f.readlines()
-
-        add_accumulator("Acc Num", 1)
-
-        statistics = get_statistic_writer()
-        statistics.init_if_required(
-            f"linea_appeal_{statistic_date_string}",
-            ["#", "MainAddress", "GPT Answer"]
-        )
-
-        chat_gpt = get_ai_chat(ai_type, token)
-
-        if get_by_key(APPEAL_ACCOUNTS_AMOUNT) is None:
-            add_value(
-                APPEAL_ACCOUNTS_AMOUNT,
-                random.randint(accounts['from'], accounts['to'])
-            )
-
-        accumulate_by_key(
-            APPEAL_ACCOUNTS, {
-                "address": account.address,
-            }
-        )
-
-        logger.info(f"Acc: {get_value("Acc Num")}")
-        logger.info(f"Acc Amount: {get_value("Acc Amount")}")
-
-        if (get_by_key(APPEAL_ACCOUNTS_AMOUNT) == len(get_by_key(APPEAL_ACCOUNTS))
-                or get_value("Acc Num") == get_value("Acc Amount")):
-            ai_style_randomized = random.choice(self.lines)
-            selected_lines = random.sample(self.reason_lines, k=random.choice([2, 3]))
-
-            reason = chat_gpt.ask(
-                self.linea_appeal_reason
-                    .replace("{random_style}", ai_style_randomized)
-                    .replace("{random_reasons}", str(selected_lines))
-            )
-            logger.info(reason)
-
-            statistics.write_row(
-                statistic_date_string,
-                [account.app_id, account.address, reason]
-            )
-
-            wallets = get_by_key(APPEAL_ACCOUNTS)
-            address_list = [wallet["address"] for wallet in wallets]
-            address_list.remove(account.address)
-            self.open_appeal_form(account, "\n".join(address_list), reason)
-            remove_key(APPEAL_ACCOUNTS)
-            remove_key(APPEAL_ACCOUNTS_AMOUNT)
-
-    def open_appeal_form(self, account, address_list, formatted_string):
-        payload = {
-            "entry.1292139045": account.address,
-            "entry.1099559693": address_list.replace("\n", "%0A"),
-            "entry.1296389817": formatted_string.replace("\n", "%0A")
-        }
-        query_string = "&".join(f"{key}={value}" for key, value in payload.items())
-        pre_filled_url = f"{self.base_url}?{query_string}"
-        print(f"Opening form: {pre_filled_url}")
-        webbrowser.open(pre_filled_url)
-
-    def parse_params(self, module_params):
-        return (
-            module_params['ai_token'],
-            module_params['accounts'],
-            module_params['write_mode'],
-            module_params['ai_type']
-        )

web3_wizzard_lib/core/modules/linea_poh_lxp.py

@@ -1,65 +0,0 @@
-import requests
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance import Erc20Balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.module.module import Module
-from sybil_engine.utils.accumulator import add_accumulator_balance, add_accumulator, get_value
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.utils.statistic_utils import statistic_date_string, get_statistic_writer
-
-
-class LineaPOHLXP(Module):
-    module_name = 'LINEA_POH_LXP'
-    module_config = None
-
-    lxp_contract = "0xd83af4fbD77f3AB65C3B1Dc4B38D7e67AEcf599A"
-
-    def execute(self, account, chain="LINEA", statistic_write="GOOGLE"):
-        poh = self.linea_poh_passed(account)
-
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-        erc20_token = Erc20Token(chain, self.lxp_contract, web3)
-        balance = erc20_token.balance(account)
-
-        logger.info(f"{account.address} balance is {balance}")
-        job_name = f"lxp_{statistic_date_string}"
-        statistics_writer = get_statistic_writer()
-
-        statistics_writer.init_if_required(
-            job_name,
-            ['#', 'Address', 'rLXP', 'POH', 'LXP', 'Remark']
-        )
-
-        if poh:
-            rLXP = balance
-            add_accumulator_balance("Total rLXP", rLXP.wei)
-        else:
-            rLXP = Erc20Balance(0, 'LINEA', "LXP")
-
-        add_accumulator_balance("Total LXP", balance.wei)
-        add_accumulator("Acc Num", 1)
-
-        row = [account.app_id, account.address, float(rLXP.readable()), poh, float(balance.readable()), ""]
-        statistics_writer.write_row(job_name, row)
-
-        if get_value("Acc Num") == get_value("Acc Amount"):
-            row = [
-                "TOTAL",
-                "",
-                float(get_value("Total rLXP").readable() / 10 ** 12),
-                "",
-                float(get_value("Total LXP").readable() / 10 ** 12),
-                ""
-            ]
-
-            statistics_writer.write_row(job_name, row)
-
-    def linea_poh_passed(self, account):
-        result = requests.get(f"https://linea-xp-poh-api.linea.build/poh/{account.address}").json()
-        return result["poh"]
-
-    def log(self):
-        return "LINEA POH LXP"

web3_wizzard_lib/core/modules/liquidity/nile_pool.py

@@ -1,64 +0,0 @@
-from loguru import logger
-from sybil_engine.data.tokens import get_tokens_for_chain
-from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.utils.retry import retry
-
-from web3_wizzard_lib.core.contract.nile_contract import NileContract
-from web3_wizzard_lib.core.modules.liquidity.pool import Pool
-
-
-class NilePool(Pool):
-    pool_contract = 'NILE_POOL'
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.nile_contract = NileContract(self.velocore_pool_contract_address, self.web3)
-
-    @retry(max_attempts=2, retry_interval={'from': 10, 'to': 20})
-    def deposit(self, amount_interval, account, token, min_native_balance, chain):
-        amount = interval_to_eth_balance(amount_interval, account, chain, self.web3)
-
-        pool_amount = self.nile_contract.get_amount_out(
-            amount,
-            get_tokens_for_chain(chain)['WETH'],
-            get_tokens_for_chain(chain)[token]
-        )[0]
-
-        nile_token = Erc20Token(chain, token, self.web3)
-
-        if nile_token.allowance(account, self.nile_contract.contract_address) < nile_token.balance(account).wei:
-            nile_token.approve(account, self.nile_contract.contract_address)
-
-        logger.info(f"Deposit {amount} and {nile_token.balance(account)}")
-        self.nile_contract.add_liquidity_eth(account, nile_token.erc20_contract.contract_address, pool_amount, amount)
-
-    @retry(max_attempts=2, retry_interval={'from': 10, 'to': 20})
-    def withdraw(self, account, token, chain):
-        weth_zero_address = get_tokens_for_chain(chain)[f"WETH_{token}_LP"]
-
-        weth_zero = Erc20Token(chain, weth_zero_address, self.web3)
-
-        if weth_zero.balance(account).wei < 10000:
-            logger.info("NILE almost zero balance")
-
-        zero_token_address = get_tokens_for_chain(chain)[token]
-
-        amount = self.nile_contract.quote_remove_liquidity_eth(
-            get_tokens_for_chain(chain)['WETH'],
-            get_tokens_for_chain(chain)[token],
-            weth_zero.balance(account).wei
-        )
-
-        if weth_zero.allowance(account, self.nile_contract.contract_address) < weth_zero.balance(account).wei:
-            weth_zero.approve(account, self.nile_contract.contract_address)
-
-        logger.info(f"Withdraw {token} on NILE {weth_zero.balance(account)}")
-
-        self.nile_contract.remove_liquidity_eth(
-            account,
-            zero_token_address,
-            weth_zero.balance(account).wei,
-            amount[0],
-            amount[1]
-        )

web3_wizzard_lib/core/modules/liquidity/pool.py

@@ -1,16 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-
-
-class Pool:
-    pool_contract = ''
-
-    def __init__(self, chain_instance, web3):
-        self.chain_contracts = get_contracts_for_chain(chain_instance['chain'])
-        self.velocore_pool_contract_address = self.chain_contracts[self.pool_contract]
-        self.web3 = web3
-
-    def deposit(self, amount_interval, account, token, min_native_balance, chain):
-        pass
-
-    def withdraw(self, account, token, chain):
-        pass

web3_wizzard_lib/core/modules/liquidity/syncswap_pool.py

@@ -1,61 +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.balance import NativeBalance
-from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-
-from web3_wizzard_lib.core.contract.syncswap_pool import SyncSwapPoolContract
-from web3_wizzard_lib.core.contract.syncswap_classic_pool import SyncSwapClassicPool
-from web3_wizzard_lib.core.contract.syncswap_router import SyncSwapRouter
-from web3_wizzard_lib.core.modules.liquidity.pool import Pool
-
-
-class SyncswapPool(Pool):
-    module_name = 'SYNCSWAP_LIQUIDITY'
-    pool_contract = 'SYNCSWAP'
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.syncswap_router = SyncSwapRouter(self.velocore_pool_contract_address, self.web3)
-
-    def deposit(self, amount_interval, account, token, min_native_balance, chain):
-        amount = interval_to_eth_balance(amount_interval, account, chain, self.web3)
-
-        pool = self.get_pool(chain)
-        pool_amount = self.get_pool_amount(account, chain, pool)
-
-        if pool_amount.wei < 10000000000:
-            logger.info(f"Deposit {amount}")
-            self.syncswap_router.add_liquidity2(account, amount)
-        else:
-            logger.info("This account already has deposit, skip")
-
-    def withdraw(self, account, token, chain):
-        pool = self.get_pool(chain)
-        pool_amount = self.get_pool_amount(account, chain, pool)
-
-        if pool_amount.wei < 10000000000:
-            logger.info(f"Withdraw amount is to small")
-            return
-
-        erc20_token = Erc20Token(chain, pool, self.web3)
-
-        if erc20_token.allowance(account, self.syncswap_router.contract_address) < pool_amount.wei:
-            erc20_token.approve(account, self.syncswap_router.contract_address)
-
-        print(erc20_token.balance(account).wei)
-
-        logger.info(f"Withdraw {pool_amount}")
-        self.syncswap_router.burn_liquidity(account, pool, pool_amount)
-
-    def get_pool_amount(self, account, chain, pool):
-        return NativeBalance(
-            SyncSwapPoolContract(pool, self.web3).balanceOf(account),
-            chain,
-            'ETH'
-        )
-
-    def get_pool(self, chain):
-        syncswap_classic_pool = SyncSwapClassicPool(get_contracts_for_chain(chain)["SYNCSWAP_CLASSIC_POOL_FACTORY"], self.web3)
-        return syncswap_classic_pool.get_pool(get_tokens_for_chain(chain)['ETH'], get_tokens_for_chain(chain)['USDC'])

web3_wizzard_lib/core/modules/liquidity/velocore_pool.py

@@ -1,55 +0,0 @@
-from loguru import logger
-from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance, interval_to_erc20_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-
-from web3_wizzard_lib.core.contract.velocore_lens import VelocoreLensContract
-from web3_wizzard_lib.core.contract.velocore_pool import VelocorePoolContract
-from web3_wizzard_lib.core.modules.liquidity.pool import Pool
-
-
-class VelocorePool(Pool):
-    module_name = 'VELOCORE_LIQUIDITY'
-    pool_contract = 'VELOCORE_POOL'
-    pool_lens_contract = 'VELOCORE_LENS'
-
-    def __init__(self, chain_instance, web3):
-        super().__init__(chain_instance, web3)
-        self.chain_instance = chain_instance
-        self.velocore_pool = VelocorePoolContract(self.velocore_pool_contract_address, self.web3)
-        self.velocore_lens = VelocoreLensContract('0xaA18cDb16a4DD88a59f4c2f45b5c91d009549e06', self.web3)
-
-    def deposit(self, amount_interval, account, token, min_native_balance, chain):
-        if token == 'ETH':
-            amount = interval_to_eth_balance(amount_interval, account, chain, self.web3)
-
-            if amount_interval == 'all_balance':
-                amount = amount.minus(min_native_balance)
-        else:
-            amount = interval_to_erc20_balance(amount_interval, account, token, chain, self.web3)
-
-            erc20_token = Erc20Token(self.chain_instance['chain'], "wstETH", self.web3)
-
-            if erc20_token.allowance(account, self.velocore_pool.contract_address) < amount.wei:
-                erc20_token.approve(account, self.velocore_pool.contract_address)
-
-        pool_address = '0x2BD146e7d95cea62C89fcCA8E529e06EEc1b053C'
-
-        logger.info(f"Deposit {amount}")
-
-        self.velocore_pool.deposit(account, int(amount.wei * 0.99), token, pool_address)
-
-    def withdraw(self, account, token, chain):
-        pool_address = '0x2BD146e7d95cea62C89fcCA8E529e06EEc1b053C'
-
-        gauge = self.velocore_lens.query_gauge(pool_address, account)
-
-        usdc_eth_vlp = gauge[14]
-        eth = gauge[9]
-
-        logger.info(f"Withdraw {eth / 10 ** 18} ETH")
-
-        if eth / 10 ** 18 < 0.0005:
-            logger.info("Withdraw amount less than 0.0005, skip")
-            return
-
-        self.velocore_pool.withdraw(account, eth, usdc_eth_vlp, pool_address)

web3_wizzard_lib/core/modules/liquidity/zerolend_liquidity.py

@@ -1,26 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.domain.balance.balance_utils import interval_to_eth_balance
-from sybil_engine.domain.balance.tokens import Erc20Token
-from sybil_engine.utils.retry import retry
-
-from web3_wizzard_lib.core.contract.zerolend_liq_contract import ZeroLendLiqContract
-from web3_wizzard_lib.core.modules.liquidity.pool import Pool
-
-
-class ZeroLendLiquidity(Pool):
-    module_name = 'ZEROLEND_LIQUIDITY'
-    pool_contract = 'ZEROLEND'
-
-    @retry(max_attempts=5, retry_interval={'from': 15 * 1, 'to': 30 * 1})
-    def deposit(self, amount_interval, account, deposit_token, min_native_balance, chain):
-        contract = ZeroLendLiqContract(get_contracts_for_chain(chain)['ZEROLEND'], self.web3)
-
-        zerolend_token = Erc20Token(chain, deposit_token, self.web3)
-
-        amount = interval_to_eth_balance(amount_interval, account, chain, self.web3)
-
-        if zerolend_token.allowance(account, contract.contract_address) < zerolend_token.balance(account).wei:
-            zerolend_token.approve(account, contract.contract_address)
-
-        contract.create_lock(account, amount)
-

web3_wizzard_lib/core/modules/liquidity_pool.py

@@ -1,60 +0,0 @@
-from venv 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.validation_utils import validate_amount_interval
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.modules.liquidity.syncswap_pool import SyncswapPool
-from web3_wizzard_lib.core.modules.liquidity.velocore_pool import VelocorePool
-from web3_wizzard_lib.core.modules.liquidity.nile_pool import NilePool
-from web3_wizzard_lib.core.modules.liquidity.zerolend_liquidity import ZeroLendLiquidity
-
-
-class LiquidityPool(Module):
-    module_name = 'LIQUIDITY_POOL'
-    module_config = 'liquidity_pool'
-
-    def execute(self, action, amount_interval, token, dex, chain, account: AppAccount):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        if dex == 'syncswap':
-            pool = SyncswapPool(chain_instance, web3)
-        elif dex == 'velocore':
-            pool = VelocorePool(chain_instance, web3)
-        elif dex == 'nile':
-            pool = NilePool(chain_instance, web3)
-        elif dex == 'zerolend':
-            pool = ZeroLendLiquidity(chain_instance, web3)
-        else:
-            raise Exception(f" {dex} Not supported")
-
-        if action == 'DEPOSIT':
-            logger.info(f"Deposit {token} to {dex}")
-            pool.deposit(amount_interval, account, token, self.min_native_balance, chain)
-        elif action == 'WITHDRAW':
-            pool.withdraw(account, token, chain)
-        else:
-            raise Exception(f"{action} action not supported")
-
-    def log(self):
-        return "LIQUIDITY_POOL"
-
-    def parse_params(self, module_params):
-        validate_amount_interval(module_params['amount'])
-
-        return [
-            module_params['action'],
-            module_params['amount'],
-            module_params['token'],
-            module_params['dex'],
-            module_params['chain']
-        ]
-
-
-class EmptyDepositException(Exception):
-    def __init__(self, message):
-        self.message = message
-        super().__init__(self.message)

web3_wizzard_lib/core/modules/merkly_refuel.py

@@ -1,87 +0,0 @@
-import random
-
-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 interval_to_eth_balance, verify_balance, from_wei_to_eth
-from sybil_engine.module.module import Module
-from sybil_engine.utils.utils import ConfigurationException, randomized_sleeping, print_exception_chain
-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.merkly_minter import MerklyMinter
-from web3_wizzard_lib.core.modules.stargate.l0_data import l0_chain_ids
-
-
-class MerklyRefuel(Module):
-    module_name = 'MERKLY_REFUEL'
-    module_config = 'merkly_refuel_config'
-
-    def execute(self, start_chain, end_chain, chains, refuel_amount_interval, sleeping_interval, account):
-        from_chain_instance = get_chain_instance(start_chain)
-        web3 = init_web3(from_chain_instance, account.proxy)
-
-        if start_chain not in chains or end_chain not in chains:
-            raise ConfigurationException(f"'end_chain' and 'start_start' should be in 'chains'. Actual:"
-                                         f"start_chain: {start_chain} end_chain: {end_chain} chains: {chains}"
-                                         )
-
-        merkly_contract = get_contracts_for_chain(start_chain)['MERKLY']
-        merkly = MerklyMinter(merkly_contract, web3)
-
-        self.shuffle_chain_sequence(start_chain, end_chain, chains)
-
-        logger.info(f"Refuel chain sequence: {chains}")
-
-        for current_chain, next_chain in zip(chains, chains[1:]):
-            native_without_min = verify_balance(self.min_native_balance, from_chain_instance, account, web3)
-
-            amount = interval_to_eth_balance(refuel_amount_interval, account, start_chain, web3)
-
-            if amount.wei > native_without_min.wei:
-                amount = native_without_min
-
-            logger.info(f"Refuel {current_chain} > {next_chain} | {amount}")
-
-            hex_amount = merkly.decimal_to_hex_padded(amount.wei)
-
-            try:
-                fee = merkly.estimate_send_fee(account, l0_chain_ids[next_chain], hex_amount)
-                logger.info(f"L0 Fee: {from_wei_to_eth(fee)} ETH")
-
-                merkly.refuel(account, l0_chain_ids[next_chain], amount.wei, fee)
-                randomized_sleeping(sleeping_interval)
-            except Exception as e:
-                print_exception_chain(e)
-
-    def shuffle_chain_sequence(self, start_chain, end_chain, chain_sequence):
-        if start_chain != '':
-            chain_sequence.remove(start_chain)
-
-        if end_chain != '' and end_chain in chain_sequence:
-            chain_sequence.remove(end_chain)
-
-        random.shuffle(chain_sequence)
-
-        if start_chain != '':
-            chain_sequence.insert(0, start_chain)
-
-        if end_chain != '':
-            chain_sequence.append(end_chain)
-
-        return chain_sequence
-
-    def log(self):
-        return "MERKLY REFUEL"
-
-    def parse_params(self, module_params):
-        validate_chain(module_params['end_chain'])
-        validate_refuel_interval(module_params['refuel_amount_interval'])
-
-        return (
-            module_params['start_chain'],
-            module_params['end_chain'],
-            module_params['chains'],
-            module_params['refuel_amount_interval'],
-            module_params['sleeping_interval']
-        )

web3_wizzard_lib/core/modules/new_rage_withdraw.py

@@ -1,41 +0,0 @@
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.module.module import Module
-from sybil_engine.utils.utils import ConfigurationException
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.new_rage_contract import NewRageContract
-
-
-class NewRageModule(Module):
-    module_name = 'NEW_RAGE_WITHDRAW'
-    module_config = 'new_rage_config'
-
-    def execute(self, token, account, chain='ARBITRUM'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, None)
-
-        if token == 'USDC':
-            contract_address = "0xf9305009FbA7E381b3337b5fA157936d73c2CF36"
-        elif token == 'GLP':
-            contract_address = "0x8478AB5064EbAC770DdCE77E7D31D969205F041E"
-        else:
-            raise ConfigurationException("No such token supported by Rage withdraw module")
-        rage = NewRageContract(contract_address, web3)
-
-        #balance = rage.balance_of(account)
-        shares = rage.max_redeem(account)
-
-        if shares > 0:
-            logger.info(f"Withdraw  {shares} shares {token}")
-            rage.redeem(account, shares)
-        else:
-            logger.info(f"Account {account.address} has 0 balance in Rage")
-
-        #add_accumulator("Total rage withdraw", balance)
-
-    def log(self):
-        return "RAGE WITHDRAW"
-
-    def parse_params(self, module_params):
-        return module_params['token'],

web3_wizzard_lib/core/modules/nft/abbys_world.py

@@ -1,22 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.alienswap_contract import AlienSwapContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class AbbysWorld(SubModule):
-    module_name = 'ABBYSWORLD'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['ABBYSWORLD']
-        abbys_world_nft = AlienSwapContract(contract_address, web3)
-
-        abbys_world_nft.purchase(account, 1)
-
-    def log(self):
-        return "ABBYS WORLD NFT"

web3_wizzard_lib/core/modules/nft/acg_worlds.py

@@ -1,25 +0,0 @@
-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.domain.balance.balance import NativeBalance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class AcgWorld(SubModule):
-    module_name = 'ACG_WORLDS'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['ACG_WORLDS']
-
-        send = Send(None, web3)
-        send.send_to_wallet(
-            account, contract_address, NativeBalance(100000000000000, chain, "ETH"), "0x1249c58b"
-        )
-
-    def log(self):
-        return "ACG WORLD NFT"

web3_wizzard_lib/core/modules/nft/alienswap_linea.py

@@ -1,22 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.alienswap_contract import AlienSwapContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class AlienSwap(SubModule):
-    module_name = 'ALIENSWAP_LINEA'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['ALIENSWAP_LINEA']
-        as_match_nft = AlienSwapContract(contract_address, web3)
-
-        as_match_nft.purchase(account, 1)
-
-    def log(self):
-        return "ALIENSWAP LINEA NFT"