web3-wizzard-lib 0.0.2__py3-none-any.whl

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

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

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)

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)

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

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()

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()

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']
+        ]

core/modules/airdrop_printer.py

@@ -0,0 +1,80 @@
+import requests
+from loguru import logger
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.module.module import Module
+from sybil_engine.utils.statistic_utils import get_statistic_writer, statistic_date_string
+from web3 import Web3
+
+
+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"

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)

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

core/modules/bank/bank_module.py

@@ -0,0 +1,99 @@
+from loguru import logger
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance_utils import get_native_balance, interval_to_eth_balance, \
+    interval_to_erc20_balance
+from sybil_engine.module.module import Order, Module
+from sybil_engine.utils.app_account_utils import AppAccount
+from sybil_engine.utils.retry import retry
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.modules.bank.basilisk import Basilisk
+from web3_wizzard_lib.core.modules import Eralend
+from web3_wizzard_lib.core.modules.bank.layerbank import LayerBank
+from web3_wizzard_lib.core.modules import MendiFinance
+from web3_wizzard_lib.core.modules.bank.aave import Aave
+from web3_wizzard_lib.core.modules 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']
+        ]

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)

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 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)