Прогрев аккаунтов в EVM-сетях - self-транзакции и транзакции на случайные адреса

• Что делает этот скрипт
• Синхронная версия скрипта
• Ссылка на репозиторий
• Модуль chain_settings.py
• Модуль сonfig.py
• Модуль functions.py
• Модуль main.py
• Асинхронный вариант скрипта
• Ссылка на репозиторий
• Модуль chain_settings.py
• Модуль config.py
• Модуль functions.py
• Модуль main.py

polygon = {

            'name': 'Polygon',

            'url':'https://polygon.llamarpc.com',

            'min_amount_for_sending':0.0001,

            'max_amount_for_sending':0.001,

            'min_transactions':5,

            'max_transactions':10,

            'explorer_url':'https://polygonscan.com/tx/'

            }

bsc = {

            'name': 'Binance Smart Chain',

            'url':'https://bsc.publicnode.com',

            'min_amount_for_sending':0.0001,

            'max_amount_for_sending':0.001,

            'min_transactions':12,

            'max_transactions':24,

            'explorer_url':'https://bscscan.com/tx/'

            }

avalanche = {

            'name': 'Avalanche',

            'url':'https://avalanche-c-chain.publicnode.com',

            'min_amount_for_sending':0.0001,

            'max_amount_for_sending':0.001,

            'min_transactions':5,

            'max_transactions':10,

            'explorer_url':'https://snowtrace.io/tx/'

            }

__all__ = ['polygon', 'bsc', 'avalanche']

TXT_WITH_PRIVATE_KEYS = 'private_keys.txt'

REPORT_TABLE_NAME = 'report_table.csv'

NUMBER_OF_VARIATION_BETWEEN_VALUES = 50

MIN_TIMESLEEP_BETWEEN_TRANSACTIONS = 100

MAX_TIMESLEEP_BETWEEN_TRANSACTIONS = 250

import time

import random

from datetime import datetime

 

import numpy as np

import pandas as pd

 

from web3 import Web3

 

from config import REPORT_TABLE_NAME, NUMBER_OF_VARIATIONS_BETWEEN_SENDING_AMOUNT, MIN_TIMESLEEP_BETWEEN_TRANSACTIONS, \

    MAX_TIMESLEEP_BETWEEN_TRANSACTIONS

import chain_settings

 

global_list_for_report = list()

def save_report_to_global_list(chain_name, wallet_address,

                               transaction_type, transaction_status,

                               amount, transaction_explorer_url, error):

    d = dict()

    d['chain_name'] = chain_name

    d['wallet_address'] = wallet_address

    d['transaction_type'] = transaction_type

    d['transaction_status'] = transaction_status

    d['sent_amount'] = amount

    d['transaction_url'] = transaction_explorer_url

    d['date'] = datetime.now().strftime('%d-%m-%Y')

    d['error'] = error

 

    global global_list_for_report

    global_list_for_report.append(d)

def export_report():

    global global_list_for_report

    df = pd.DataFrame.from_dict(global_list_for_report)

    df.to_csv(REPORT_TABLE_NAME, index=False)

def create_random_value_from_range(min_value, max_value):

    random_value_between_range = random.choice(range(min_value, max_value))

 

    return random_value_between_range

def create_random_amount_for_sending(min_value_for_sending, max_value_for_sending,

                                     number_of_variations_between_sending_amount):

    random_position = random.choice(range(number_of_variations_between_sending_amount))

 

    random_amount_for_sending = np.linspace(min_value_for_sending,

                                            max_value_for_sending,

                                            num=number_of_variations_between_sending_amount)[random_position]

 

    return random_amount_for_sending

def transaction_settings(web3, from_address, to_address, amount):

    amount_wei = web3.to_wei(amount, 'ether')

 

    gas_price = web3.eth.gas_price

 

    estimated_gas = web3.eth.estimate_gas({

        'to': to_address,

        'value': amount_wei,

    })

 

    nonce = web3.eth.get_transaction_count(from_address)

 

    transaction = {

        'chainId': web3.eth.chain_id,

        'from': from_address,

        'to': to_address,

        'value': amount_wei,

        'nonce': nonce,

        'gasPrice': gas_price,

        'gas': estimated_gas,

    }

 

    return transaction

def create_sign_send_transaction(web3, from_address, to_address, amount, private_key):

    create_transaction = transaction_settings(

        web3=web3,

        from_address=from_address,

        to_address=to_address,

        amount=amount

    )

 

    signed_transaction = web3.eth.account.sign_transaction(create_transaction, private_key)

 

    transaction_hash = web3.eth.send_raw_transaction(signed_transaction.rawTransaction)

 

    return transaction_hash.hex()

def self_transaction(web3, amount, private_key,

                     min_timesleep_between_transactions,

                     max_timesleep_between_transactions,

                     chain_name, explorer_url):

 

    try:

        timesleep_value = create_random_value_from_range(5, 15)

        time.sleep(timesleep_value)

 

        transaction_type = 'SELF-transaction'

        print(f'Key {private_key[:6]}...{private_key[-6:]}, {transaction_type} {chain_name}')

 

        my_address = web3.eth.account.from_key(private_key).address

 

        transaction_hash = create_sign_send_transaction(web3, my_address, my_address,

                                                        amount, private_key)

 

        print(f'Hash {transaction_type} {chain_name} {transaction_hash}')

 

        print(f'Recording data in a report')

        save_report_to_global_list(chain_name, my_address,

                                   transaction_type, 'SUCCESS',

                                   amount, f'{explorer_url}{transaction_hash}', '-')

 

        timesleep_value = create_random_value_from_range(min_timesleep_between_transactions,

                                                         max_timesleep_between_transactions)

        print(f'Pause {timesleep_value} sec. after {transaction_type} {chain_name} ', '\n')

        time.sleep(timesleep_value)

 

    except Exception as error:

        print(f'{transaction_type} {chain_name}, error -  {error}', '\n')

        save_report_to_global_list(chain_name, my_address,

                                   transaction_type, 'ERROR',

                                   amount, '-', error)

def random_transaction(web3, amount, private_key,

                       min_timesleep_between_transactions,

                       max_timesleep_between_transactions,

                       chain_name, explorer_url):

    try:

        timesleep_value = create_random_value_from_range(5, 15)

        time.sleep(timesleep_value)

 

        transaction_type = 'RANDOM-transaction'

        print(f'Key {private_key[:6]}...{private_key[-6:]}, {transaction_type} {chain_name}', '\n')

 

        account = web3.eth.account.create()

        random_wallet = account.address

 

        my_address = web3.eth.account.from_key(private_key).address

        prepared_wallet = web3.to_checksum_address(random_wallet)

 

        transaction_hash = create_sign_send_transaction(web3, my_address, prepared_wallet,

                                                        amount, private_key)

 

        print(f'Hash {transaction_type} {chain_name} {transaction_hash}' )

 

        print(f'Recording data in a report')

        save_report_to_global_list(chain_name, my_address,

                                   transaction_type, 'SUCCESS',

                                   amount, f'{explorer_url}{transaction_hash}', '-')

 

        timesleep_value = create_random_value_from_range(min_timesleep_between_transactions,

                                                         max_timesleep_between_transactions)

        print(f'Pause {timesleep_value} sec. after {transaction_type} {chain_name} ', '\n')

        time.sleep(timesleep_value)

 

    except Exception as error:

        print(f'{transaction_type} {chain_name}, error -  {error}', '\n')

        save_report_to_global_list(chain_name, my_address,

                                   transaction_type, 'ERROR',

                                   amount, '-', error)

def main_function_make_random_or_self_txns(private_key):

    try:

        for chain in map(chain_settings.__dict__.get, chain_settings.__all__):

            chain_name = chain['name']

 

            print(f'Process has been launched for {private_key[:6]}...{private_key[-6:]} on the network {chain_name}')

 

            web3 = Web3(Web3.HTTPProvider(chain['url']))

 

            if not web3.is_connected():

                print(f'Connection to {chain_name} is not established', '\n')

 

                my_address = web3.eth.account.from_key(private_key).address

                save_report_to_global_list(chain_name, my_address,

                                           '-', 'ERROR',

                                           '-', '-',

                                           'Connection is not established')

                time.sleep(5)

                continue

 

            print(f'Connection to {chain_name} was established', '\n')

 

            transactions_quantity = create_random_value_from_range(chain['min_transactions'],

                                                                   chain['max_transactions'])

 

            for _ in range(transactions_quantity):

                amount = create_random_amount_for_sending(chain['min_amount_for_sending'],

                                                          chain['max_amount_for_sending'],

                                                          NUMBER_OF_VARIATIONS_BETWEEN_SENDING_AMOUNT)

 

                random.choice([self_transaction, random_transaction])(web3, amount, private_key,

                                                                      MIN_TIMESLEEP_BETWEEN_TRANSACTIONS,

                                                                      MAX_TIMESLEEP_BETWEEN_TRANSACTIONS,

                                                                      chain_name, chain['explorer_url'])

 

    except Exception as error:

        print(error, '\n')

        save_report_to_global_list('-', private_key,

                                   '-', 'ERROR',

                                   '-', '-',

                                   'Some system error occurred during the process.')

from functions import main_function_make_random_or_self_txns, export_report

from config import TXT_WITH_PRIVATE_KEYS

def main():

    with open(TXT_WITH_PRIVATE_KEYS) as file:

        list_of_private_keys = [line.strip() for line in file.readlines()]

 

    for private_key in list_of_private_keys:

        main_function_make_random_or_self_txns(private_key)

 

    export_report()

if __name__ == '__main__':

    main()

polygon = {

            'name': 'Polygon',

            'url':'https://polygon.llamarpc.com',

            'min_amount_for_sending':0.0001,

            'max_amount_for_sending':0.001,

            'min_transactions':5,

            'max_transactions':10,

            'explorer_url':'https://polygonscan.com/tx/'

            }

bsc = {

            'name': 'Binance Smart Chain',

            'url':'https://bsc.publicnode.com',

            'min_amount_for_sending':0.0001,

            'max_amount_for_sending':0.001,

            'min_transactions':12,

            'max_transactions':24,

            'explorer_url':'https://bscscan.com/tx/'

            }

avalanche = {

            'name': 'Avalanche',

            'url':'https://avalanche-c-chain.publicnode.com',

            'min_amount_for_sending':0.0001,

            'max_amount_for_sending':0.001,

            'min_transactions':5,

            'max_transactions':10,

            'explorer_url':'https://snowtrace.io/tx/'

            }

__all__ = ['polygon', 'bsc', 'avalanche']

TXT_WITH_PRIVATE_KEYS = 'private_keys.txt'

REPORT_TABLE_NAME = 'report_table.csv'

NUMBER_OF_VARIATION_BETWEEN_VALUES = 50

MIN_TIMESLEEP_BETWEEN_TRANSACTIONS = 100

MAX_TIMESLEEP_BETWEEN_TRANSACTIONS = 250

NUMBER_OF_PROCESSES = 4

MIN_TIMESLEEP_BETWEEN_PROCESSES = 50

MAX_TIMESLEEP_BETWEEN_PROCESSES = 100

colors = ['\033[32m',

          '\033[33m',

          '\033[34m',

          '\033[35m',

          '\033[36m',

          '\033[37m']

import asyncio

import random

from datetime import datetime

 

import numpy as np

import pandas as pd

 

from config import REPORT_TABLE_NAME

global_list_for_report = list()

lock = asyncio.Lock()

async def save_report_to_global_list(chain_name, wallet_address,

                                     transaction_type, transaction_status,

                                     amount, transaction_explorer_url, error):

    async with lock:

        d = dict()

        d['chain_name'] = chain_name

        d['wallet_address'] = wallet_address

        d['transaction_type'] = transaction_type

        d['transaction_status'] = transaction_status

        d['sent_amount'] = amount

        d['transaction_url'] = transaction_explorer_url

        d['date'] = datetime.now().strftime('%d-%m-%Y')

        d['error'] = error

 

        global global_list_for_report

        global_list_for_report.append(d)

def export_report():

    global global_list_for_report

    df = pd.DataFrame.from_dict(global_list_for_report)

    df.to_csv(REPORT_TABLE_NAME, index=False)

def create_random_value_from_range(min_value, max_value):

    random_value_between_range = random.choice(range(min_value, max_value))

 

    return random_value_between_range

def create_random_amount_for_sending(min_value_for_sending, max_value_for_sending,

                                     number_of_variations_between_sending_amount):

    random_position = random.choice(range(number_of_variations_between_sending_amount))

 

    random_amount_for_sending = np.linspace(min_value_for_sending,

                                            max_value_for_sending,

                                            num=number_of_variations_between_sending_amount)[random_position]

 

    return random_amount_for_sending

async def transaction_settings(web3, from_address, to_address, amount):

    amount_wei = web3.to_wei(amount, 'ether')

 

    gas_price = await web3.eth.gas_price

 

    estimated_gas = await web3.eth.estimate_gas({

        'to': to_address,

        'value': amount_wei,

    })

 

    nonce = await web3.eth.get_transaction_count(from_address)

 

    transaction = {

        'chainId': await web3.eth.chain_id,

        'from': from_address,

        'to': to_address,

        'value': amount_wei,

        'nonce': nonce,

        'gasPrice': gas_price,

        'gas': estimated_gas,

    }

 

    return transaction

async def create_sign_send_transaction(web3, from_address, to_address, amount, private_key):

    create_transaction = await transaction_settings(

        web3=web3,

        from_address=from_address,

        to_address=to_address,

        amount=amount

    )

 

    signed_transaction = web3.eth.account.sign_transaction(create_transaction, private_key)

 

    transaction_hash = await web3.eth.send_raw_transaction(signed_transaction.rawTransaction)

 

    return transaction_hash.hex()

async def self_transaction(web3, amount, private_key,

                           min_timesleep_between_transactions,

                           max_timesleep_between_transactions,

                           chain_name, explorer_url,

                           number_of_process, color):

 

    try:

        timesleep_value = create_random_value_from_range(5, 15)

        await asyncio.sleep(timesleep_value)

 

        transaction_type = 'SELF-transaction'

        print(f'{color}Process №{number_of_process}, key {private_key[:6]}...{private_key[-6:]}, {transaction_type} {chain_name}')

 

        my_address = web3.eth.account.from_key(private_key).address

 

        transaction_hash = await create_sign_send_transaction(web3, my_address, my_address,

                                                              amount, private_key)

 

        print(f'{color}Process №{number_of_process}, hash {transaction_type} {chain_name} {transaction_hash}')

 

        print(f'{color}Process №{number_of_process}, recording data in a report')

        await save_report_to_global_list(chain_name, my_address,

                                         transaction_type, 'SUCCESS',

                                         amount, f'{explorer_url}{transaction_hash}', '-')

 

        timesleep_value = create_random_value_from_range(min_timesleep_between_transactions,

                                                         max_timesleep_between_transactions)

        print(f'{color}Process №{number_of_process}, pause {timesleep_value} sec. after {transaction_type} {chain_name} ', '\n')

        await asyncio.sleep(timesleep_value)

 

    except Exception as error:

        print(f'{color}Process №{number_of_process}, {transaction_type} {chain_name}, error -  {error}', '\n')

        await save_report_to_global_list(chain_name, my_address,

                                         transaction_type, 'ERROR',

                                         amount, '-', error)

async def random_transaction(web3, amount, private_key,

                             min_timesleep_between_transactions,

                             max_timesleep_between_transactions,

                             chain_name, explorer_url,

                             number_of_process, color):

    try:

        timesleep_value = create_random_value_from_range(5, 15)

        await asyncio.sleep(timesleep_value)

 

        transaction_type = 'RANDOM-transaction'

        print(f'{color}Process №{number_of_process}, key {private_key[:6]}...{private_key[-6:]}, {transaction_type} {chain_name}', '\n')

 

        account = web3.eth.account.create()

        random_wallet = account.address

 

        my_address = web3.eth.account.from_key(private_key).address

        prepared_wallet = web3.to_checksum_address(random_wallet)

 

        transaction_hash = await create_sign_send_transaction(web3, my_address, prepared_wallet,

                                                              amount, private_key)

 

        print(f'{color}Process №{number_of_process}, hash {transaction_type} {chain_name} {transaction_hash}' )

 

        print(f'{color}Process №{number_of_process}, recording data in a report')

        await save_report_to_global_list(chain_name, my_address,

                                         transaction_type, 'SUCCESS',

                                         amount, f'{explorer_url}{transaction_hash}', '-')

 

        timesleep_value = create_random_value_from_range(min_timesleep_between_transactions,

                                                         max_timesleep_between_transactions)

        print(f'{color}Process №{number_of_process}, pause {timesleep_value} sec. after {transaction_type} {chain_name} ', '\n')

        await asyncio.sleep(timesleep_value)

 

    except Exception as error:

        print(f'{color}Process №{number_of_process}, {transaction_type} {chain_name}, error -  {error}', '\n')

        await save_report_to_global_list(chain_name, my_address,

                                         transaction_type, 'ERROR',

                                         amount, '-', error)

import asyncio

 

from web3 import AsyncWeb3

 

from functions import *

from config import *

import chain_settings

async def producer(queue, private_key, number):

    await queue.put((private_key, number))

    print('\n', f'\033[31;47mPrivate key {private_key[:6]}...{private_key[-6:]} has been added to the queue. Queue №{number}\033[0m',

          '\n')

async def consumer(queue, color):

    while True:

        item = await queue.get()

        private_key, process_number = item

 

        timesleep_value = create_random_value_from_range(MIN_TIMESLEEP_BETWEEN_PROCESSES,

                                                         MAX_TIMESLEEP_BETWEEN_PROCESSES)

 

        print(f'{color} Before the start of the process №{process_number} {timesleep_value} sec.', '\n')

 

        await asyncio.sleep(timesleep_value)

 

        try:

            for chain in map(chain_settings.__dict__.get, chain_settings.__all__):

                chain_name = chain['name']

 

                print(f'{color}Process №{process_number} has been launched for {private_key[:6]}...{private_key[-6:]} on the network {chain_name}')

 

                web3 = AsyncWeb3(AsyncWeb3.AsyncHTTPProvider(chain['url']))

 

                if not await web3.is_connected():

                    print(f'{color}Process №{process_number} connection to {chain_name} is not established', '\n')

 

                    my_address = web3.eth.account.from_key(private_key).address

                    await save_report_to_global_list(chain_name, my_address,

                                                     '-', 'ERROR',

                                                     '-', '-',

                                                     'Connection is not established')

                    await asyncio.sleep(5)

                    continue

 

                print(f'{color}Process №{process_number} connection to {chain_name} was established', '\n')

 

                transactions_quantity = create_random_value_from_range(chain['min_transactions'],

                                                                       chain['max_transactions'])

 

                for _ in range(transactions_quantity):

                    amount = create_random_amount_for_sending(chain['min_amount_for_sending'],

                                                              chain['max_amount_for_sending'],

                                                              NUMBER_OF_VARIATIONS_BETWEEN_SENDING_AMOUNT)

 

                    await random.choice([self_transaction, random_transaction])(web3, amount, private_key,

                                                                                MIN_TIMESLEEP_BETWEEN_TRANSACTIONS,

                                                                                MAX_TIMESLEEP_BETWEEN_TRANSACTIONS,

                                                                                chain_name, chain['explorer_url'],

                                                                                process_number, color)

 

            queue.task_done()

 

        except Exception as error:

            print(error, '\n')

            await save_report_to_global_list('-', private_key,

                                             '-', 'ERROR',

                                             '-', '-',

                                             'Some system error occurred during the process.')

            queue.task_done()

async def main():

    queue = asyncio.Queue(maxsize=NUMBER_OF_PROCESSES)

    pended = 0

 

    with open(TXT_WITH_PRIVATE_KEYS) as file:

        list_of_private_keys = [line.strip() for line in file.readlines()]

 

    producers = []

    for private_key in list_of_private_keys:

        pended += 1

        task = asyncio.create_task(producer(queue, private_key, pended))

        producers.append(task)

 

    consumers = []

    for _ in range(NUMBER_OF_PROCESSES):

        task = asyncio.create_task(consumer(queue, colors[random.choice(range(len(colors)))]))

        consumers.append(task)

 

    await asyncio.gather(*producers)

    await queue.join()

 

    for c in consumers:

        c.cancel()

 

    export_report()

if __name__ == '__main__':

    asyncio.run(main())