DEV Community: MMDRZA

ETH Wallet Hack With Mnemonic Crack Python

MMDRZA — Wed, 13 Apr 2022 08:19:10 +0000

Ethereum Wallet Hack With Mnemonic Crack Python

burte force and cracking ethereum wallet in mnemonic (keypharse) with python and highspeed checking total transaction without api , no needed install package . all in one file and looper for windows and linux .cmd– .sh .
checked wallet with 12 & 24 words (128-256)
– imported language ENGLISH , french , korea , china , japon
– tested and checked with high speed method without api key for total transaction and final balance.
– save just rich wallet (tx > 0) on text file .
– save address ethereum wallet and private key , mnemonic wallet ethereum on file text.
– use and running windows / linux / mac .

Download Source Follow Link :

https://mmdrza.com/ethereum-wallet-hack-with-mnemonic-crack-python/

python source download

Ethereum Wallet Hack With Mnemonic Crack Python

MMDRZA — Wed, 13 Apr 2022 08:17:26 +0000

Ethereum Wallet Hack With Mnemonic Crack Python

Download Source Follow Link :

https://mmdrza.com/ethereum-wallet-hack-with-mnemonic-crack-python/

python source download

Generated Bitcoin Address and Private key (hdwallet)

MMDRZA — Mon, 28 Mar 2022 06:29:22 +0000

Bitcoin HDWallet Generator (Privatekey + address)

Bitcoin wallet creat and check private key and address , with total transaction (use HDWallet)

View Full Source Here

genereted bitcoin wallet private key and address
genereted from random private key (hexer)
check wallet details and all transaction without apikey
save wallet > 0 on text file
easy install windows and linux (00INSTALL.cmd and 00INSTALL.sh)

for install package on windows ./00INSTALL.cmd or this:

pip install colorama
pip install hdwallet
pip install lxml
pip install requests

for install package on Linux ./00INSTALL.sh or this:

pip install colorama
pip install hdwallet
pip install lxml
pip install requests

can use easy running with loop:
use btcHDall.cmd (btcHDall.py) For Genereted and Checked 4 type Address All in One (p2pkh + p2sh + p2wpkh + p2wsh)

./btcHDall.cmd
./p2pkh.cmd
./p2sh.cmd
./p2wpkh.cmd
./p2wsh.cmd

Linux:

sh btcHDall.sh
sh p2pkh.sh
sh p2sh.sh
sh p2wpkh.sh
sh p2wsh.sh

Genereted p2pkh address use p2pkh.py or p2pkh.cmd or p2pkh.sh p2pkh.py (source)

Genereted p2wpkh address use p2wpkh.py or p2wpkh.cmd or p2wpkh.sh p2wpkh.py (source)

Genereted p2sh address use p2sh.py or p2sh.cmd or p2sh.sh p2sh.py (source)

Generated p2wsh address use p2wsh.py or p2wsh.cmd or p2wsh.sh p2wsh.py (source)

View Full Source Here

# ================================================
# DONATE (BTC) : 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
# Website : Mmdrza.Com
# Email : X4@mmdrza.Com
# Dev.to/Mmdrza
# Github.com/Pymmdrza
# ================================================

bitcoin wallet generated wait random private key (HDWallet)

MMDRZA — Mon, 28 Mar 2022 06:27:57 +0000

Bitcoin HDWallet Generator (Privatekey + address)

Bitcoin wallet creat and check private key and address , with total transaction (use HDWallet)

View Full Source Here

genereted bitcoin wallet private key and address
genereted from random private key (hexer)
check wallet details and all transaction without apikey
save wallet > 0 on text file
easy install windows and linux (00INSTALL.cmd and 00INSTALL.sh)

for install package on windows ./00INSTALL.cmd or this:

pip install colorama
pip install hdwallet
pip install lxml
pip install requests

for install package on Linux ./00INSTALL.sh or this:

pip install colorama
pip install hdwallet
pip install lxml
pip install requests

can use easy running with loop:
use btcHDall.cmd (btcHDall.py) For Genereted and Checked 4 type Address All in One (p2pkh + p2sh + p2wpkh + p2wsh)

./btcHDall.cmd
./p2pkh.cmd
./p2sh.cmd
./p2wpkh.cmd
./p2wsh.cmd

Linux:

sh btcHDall.sh
sh p2pkh.sh
sh p2sh.sh
sh p2wpkh.sh
sh p2wsh.sh

Genereted p2pkh address use p2pkh.py or p2pkh.cmd or p2pkh.sh p2pkh.py (source)

Genereted p2wpkh address use p2wpkh.py or p2wpkh.cmd or p2wpkh.sh p2wpkh.py (source)

Genereted p2sh address use p2sh.py or p2sh.cmd or p2sh.sh p2sh.py (source)

Generated p2wsh address use p2wsh.py or p2wsh.cmd or p2wsh.sh p2wsh.py (source)

View Full Source Here

# ================================================
# DONATE (BTC) : 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
# Website : Mmdrza.Com
# Email : X4@mmdrza.Com
# Dev.to/Mmdrza
# Github.com/Pymmdrza
# ================================================

Bitcoin All Transactions Report

MMDRZA — Mon, 21 Mar 2022 17:23:44 +0000

Bitcoin All Transactions Report Without Needed API KEY with Python > 3.6 , During the day there are many people who do a set of transactions in their daily work. We have now prepared the source code, which is at an intermediate level with the Python programming language. In this program, you query 18 transactions per request, and if a new transaction is added to each block, it will also be displayed in the tables of this program. . During the high performance of this program, we did not forget the graphic environment of the console, and with the Rich Python package, we provided eye-catching tables for users.

In the Bitcoin transaction reporting program, all data is received from the blockchain every second, and tables are updated if a new transaction is created. This program takes up the least amount of RAM space and provides information to its user with very high speed and efficiency. In this program, rich and lxml , time , requests packages are used, which we first install from the console or terminal of our system with the following command line.

pip install rich
pip install lxml

pip3 install rich lxml

install package after installing run program bitcoin transaction reporter with this code on terminal :

python reportBTCV3.py

or 

python3 reportBTCV3.py

# Programmer Mmdrza                                                                   #
# Web Mmdrza.Com                                                                      #
# Email X4@Mmdrza.Com                                                                 #
# GitHub.Com/PyMmdrza                                                                 #
# Dev.to/Mmdrza                                                                       #
# PythonWithMmdrza.Medium.Com                                                         #
# 


import time

from Tools.scripts.generate_opcode_h import footer
from rich.progress import track, Progress, SpinnerColumn, BarColumn, TextColumn
import requests
from lxml import html
from rich import box
from rich.console import Console
from rich.table import Table
import rich
count = 1
while True:
    urlblock = 'https://www.blockchain.com/btc/unconfirmed-transactions'
    respone_block = requests.get(urlblock)
    byte_string_block = respone_block.content
    source_code_block = html.fromstring(byte_string_block)
    xpatchblock_txid = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[2]/div[1]/div[2]'
    xpatchblock_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[2]/div[3]/div[2]/span'
    xpatchblock_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[2]/div[4]/div[2]/span'
    xpatchblock3_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[4]/div[1]/div[2]'
    xpatchblock3_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[4]/div[3]/div[2]/span'
    xpatchblock3_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[4]/div[4]/div[2]/span'
    xpatchblock4_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[5]/div[1]/div[2]'
    xpatchblock4_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[5]/div[3]/div[2]'
    xpatchblock4_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[5]/div[4]/div[2]'
    xpatchblock6_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[6]/div[1]/div[2]'
    xpatchblock6_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[6]/div[3]/div[2]/span'
    xpatchblock6_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[6]/div[4]/div[2]/span'
    xpatchblock7_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[7]/div[1]/div[2]'
    xpatchblock7_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[7]/div[3]/div[2]/span'
    xpatchblock7_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[7]/div[4]/div[2]/span'
    xpatchblock8_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[8]/div[1]/div[2]'
    xpatchblock8_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[8]/div[3]/div[2]/span'
    xpatchblock8_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[8]/div[4]/div[2]/span'
    xpatchblock9_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[9]/div[1]/div[2]'
    xpatchblock9_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[9]/div[3]/div[2]/span'
    xpatchblock9_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[9]/div[4]/div[2]/span'
    xpatchblock10_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[10]/div[1]/div[2]'
    xpatchblock10_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[10]/div[3]/div[2]/span'
    xpatchblock10_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[10]/div[4]/div[2]/span'
    xpatchblock11_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[11]/div[1]/div[2]'
    xpatchblock11_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[11]/div[3]/div[2]/span'
    xpatchblock11_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[11]/div[4]/div[2]/span'
    xpatchblock12_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[12]/div[1]/div[2]'
    xpatchblock12_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[12]/div[3]/div[2]/span'
    xpatchblock12_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[12]/div[4]/div[2]/span'
    xpatchblock13_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[13]/div[1]/div[2]'
    xpatchblock13_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[13]/div[3]/div[2]/span'
    xpatchblock13_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[13]/div[4]/div[2]/span'
    xpatchblock14_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[14]/div[1]/div[2]'
    xpatchblock14_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[14]/div[3]/div[2]/span'
    xpatchblock14_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[14]/div[4]/div[2]/span'
    xpatchblock15_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[15]/div[1]/div[2]'
    xpatchblock15_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[15]/div[3]/div[2]/span'
    xpatchblock15_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[15]/div[4]/div[2]/span'
    xpatchblock16_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[16]/div[1]/div[2]'
    xpatchblock16_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[16]/div[3]/div[2]/span'
    xpatchblock16_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[16]/div[4]/div[2]/span'
    xpatchblock17_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[17]/div[1]/div[2]'
    xpatchblock17_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[17]/div[3]/div[2]/span'
    xpatchblock17_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[17]/div[4]/div[2]/span'
    xpatchblock18_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[18]/div[1]/div[2]'
    xpatchblock18_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[18]/div[3]/div[2]/span'
    xpatchblock18_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[18]/div[4]/div[2]/span'
    xpatchblock19_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[19]/div[1]/div[2]'
    xpatchblock19_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[19]/div[3]/div[2]/span'
    xpatchblock19_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[19]/div[4]/div[2]/span'
    xpatchblock20_hex = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[20]/div[1]/div[2]'
    xpatchblock20_btc = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[20]/div[3]/div[2]/span'
    xpatchblock20_usd = '/html/body/div[1]/div[3]/div[2]/div/div/div[2]/div/div[20]/div[4]/div[2]/span'
    # =========================================[MMDRZA.COM]=============================================
    blocktreetxid = source_code_block.xpath(xpatchblock_txid)
    blocktree_btc = source_code_block.xpath(xpatchblock_btc)
    blocktree_usd = source_code_block.xpath(xpatchblock_usd)
    blocktree3_hex = source_code_block.xpath(xpatchblock3_hex)
    blocktree4_hex = source_code_block.xpath(xpatchblock4_hex)
    blocktree3_btc = source_code_block.xpath(xpatchblock3_btc)
    blocktree4_btc = source_code_block.xpath(xpatchblock4_btc)
    blocktree3_usd = source_code_block.xpath(xpatchblock3_usd)
    blocktree4_usd = source_code_block.xpath(xpatchblock4_usd)
    blocktree_6_hex = source_code_block.xpath(xpatchblock6_hex)
    blocktree_6_btc = source_code_block.xpath(xpatchblock6_btc)
    blocktree_6_usd = source_code_block.xpath(xpatchblock6_usd)
    blocktree_7_hex = source_code_block.xpath(xpatchblock7_hex)
    blocktree_7_btc = source_code_block.xpath(xpatchblock7_btc)
    blocktree_7_usd = source_code_block.xpath(xpatchblock7_usd)
    blocktree_8_hex = source_code_block.xpath(xpatchblock8_hex)
    blocktree_8_btc = source_code_block.xpath(xpatchblock8_btc)
    blocktree_8_usd = source_code_block.xpath(xpatchblock8_usd)
    blocktree_9_hex = source_code_block.xpath(xpatchblock9_hex)
    blocktree_9_btc = source_code_block.xpath(xpatchblock9_btc)
    blocktree_9_usd = source_code_block.xpath(xpatchblock9_usd)
    blocktree_10_hex = source_code_block.xpath(xpatchblock10_hex)
    blocktree_10_btc = source_code_block.xpath(xpatchblock10_btc)
    blocktree_10_usd = source_code_block.xpath(xpatchblock10_usd)
    blocktree_11_hex = source_code_block.xpath(xpatchblock11_hex)
    blocktree_11_btc = source_code_block.xpath(xpatchblock11_btc)
    blocktree_11_usd = source_code_block.xpath(xpatchblock11_usd)
    blocktree_12_hex = source_code_block.xpath(xpatchblock12_hex)
    blocktree_12_btc = source_code_block.xpath(xpatchblock12_btc)
    blocktree_12_usd = source_code_block.xpath(xpatchblock12_usd)
    blocktree_13_hex = source_code_block.xpath(xpatchblock13_hex)
    blocktree_13_btc = source_code_block.xpath(xpatchblock13_btc)
    blocktree_13_usd = source_code_block.xpath(xpatchblock13_usd)
    blocktree_14_hex = source_code_block.xpath(xpatchblock14_hex)
    blocktree_14_btc = source_code_block.xpath(xpatchblock14_btc)
    blocktree_14_usd = source_code_block.xpath(xpatchblock14_usd)
    blocktree_15_hex = source_code_block.xpath(xpatchblock15_hex)
    blocktree_15_btc = source_code_block.xpath(xpatchblock15_btc)
    blocktree_15_usd = source_code_block.xpath(xpatchblock15_usd)
    blocktree_16_hex = source_code_block.xpath(xpatchblock16_hex)
    blocktree_16_btc = source_code_block.xpath(xpatchblock16_btc)
    blocktree_16_usd = source_code_block.xpath(xpatchblock16_usd)
    blocktree_17_hex = source_code_block.xpath(xpatchblock17_hex)
    blocktree_17_btc = source_code_block.xpath(xpatchblock17_btc)
    blocktree_17_usd = source_code_block.xpath(xpatchblock17_usd)
    blocktree_18_hex = source_code_block.xpath(xpatchblock18_hex)
    blocktree_18_btc = source_code_block.xpath(xpatchblock18_btc)
    blocktree_18_usd = source_code_block.xpath(xpatchblock18_usd)
    blocktree_19_hex = source_code_block.xpath(xpatchblock19_hex)
    blocktree_19_btc = source_code_block.xpath(xpatchblock19_btc)
    blocktree_19_usd = source_code_block.xpath(xpatchblock19_usd)
    blocktree_20_hex = source_code_block.xpath(xpatchblock20_hex)
    blocktree_20_btc = source_code_block.xpath(xpatchblock20_btc)
    blocktree_20_usd = source_code_block.xpath(xpatchblock20_usd)
    # =========================================[MMDRZA.COM]=============================================
    block3btc = str(blocktree3_btc[0].text_content())
    block4hex = str(blocktree4_hex[0].text_content())
    block4btc = str(blocktree4_btc[0].text_content())
    block3usd = str(blocktree3_usd[0].text_content())
    block4usd = str(blocktree4_usd[0].text_content())
    block3hex = str(blocktree3_hex[0].text_content())
    blocktxid = str(blocktreetxid[0].text_content())
    blockbtc = str(blocktree_btc[0].text_content())
    blockusd = str(blocktree_usd[0].text_content())
    chblock1btc = str(blockbtc)[0]
    chblock2btc = str(block3btc)[0]
    chblock3btc = str(block4btc)[0]
    blockhex_6 = str(blocktree_6_hex[0].text_content())
    blockhex_7 = str(blocktree_7_hex[0].text_content())
    blockhex_8 = str(blocktree_8_hex[0].text_content())
    blockhex_9 = str(blocktree_9_hex[0].text_content())
    blockhex_10 = str(blocktree_10_hex[0].text_content())
    blockhex_11 = str(blocktree_11_hex[0].text_content())
    blockhex_12 = str(blocktree_12_hex[0].text_content())
    blockhex_13 = str(blocktree_13_hex[0].text_content())
    blockhex_14 = str(blocktree_14_hex[0].text_content())
    blockhex_15 = str(blocktree_15_hex[0].text_content())
    blockhex_16 = str(blocktree_16_hex[0].text_content())
    blockhex_17 = str(blocktree_17_hex[0].text_content())
    blockhex_18 = str(blocktree_18_hex[0].text_content())
    blockhex_19 = str(blocktree_19_hex[0].text_content())
    blockhex_20 = str(blocktree_20_hex[0].text_content())
    blockbtc_6 = str(blocktree_6_btc[0].text_content())
    blockbtc_7 = str(blocktree_7_btc[0].text_content())
    blockbtc_8 = str(blocktree_8_btc[0].text_content())
    blockbtc_9 = str(blocktree_9_btc[0].text_content())
    blockbtc_10 = str(blocktree_10_btc[0].text_content())
    blockbtc_11 = str(blocktree_11_btc[0].text_content())
    blockbtc_12 = str(blocktree_12_btc[0].text_content())
    blockbtc_13 = str(blocktree_13_btc[0].text_content())
    blockbtc_14 = str(blocktree_14_btc[0].text_content())
    blockbtc_15 = str(blocktree_15_btc[0].text_content())
    blockbtc_16 = str(blocktree_16_btc[0].text_content())
    blockbtc_17 = str(blocktree_17_btc[0].text_content())
    blockbtc_18 = str(blocktree_18_btc[0].text_content())
    blockbtc_19 = str(blocktree_19_btc[0].text_content())
    blockbtc_20 = str(blocktree_20_btc[0].text_content())
    blockusd_6 = str(blocktree_6_usd[0].text_content())
    blockusd_7 = str(blocktree_7_usd[0].text_content())
    blockusd_8 = str(blocktree_8_usd[0].text_content())
    blockusd_9 = str(blocktree_9_usd[0].text_content())
    blockusd_10 = str(blocktree_10_usd[0].text_content())
    blockusd_11 = str(blocktree_11_usd[0].text_content())
    blockusd_12 = str(blocktree_12_usd[0].text_content())
    blockusd_13 = str(blocktree_13_usd[0].text_content())
    blockusd_14 = str(blocktree_14_usd[0].text_content())
    blockusd_15 = str(blocktree_15_usd[0].text_content())
    blockusd_16 = str(blocktree_16_usd[0].text_content())
    blockusd_17 = str(blocktree_17_usd[0].text_content())
    blockusd_18 = str(blocktree_18_usd[0].text_content())
    blockusd_19 = str(blocktree_19_usd[0].text_content())
    blockusd_20 = str(blocktree_20_usd[0].text_content())
    # =========================================[MMDRZA.COM]=============================================
    row_styles = ["on grey15", "on grey11", "on grey15", "on grey11"]  # T his is a bit messy...?

    table = Table(title_style="italic gold1", header_style="italic", title="\n\n\nBitcoin Transaction Reporter V3\n------- M M D R Z A . C o M -------",
                  border_style="green",
                  box=box.ROUNDED, show_lines=False, row_styles=row_styles, show_edge=True)

    table.add_column("TXID",justify="center", style="bold", no_wrap=True)
    table.add_column("BTC", style="green", no_wrap=True)
    table.add_column("USD", style="gold1", no_wrap=True)
    table.add_row(str(blocktxid),str(blockbtc),str(blockusd))
    table.add_row(str(block3hex), str(block3btc), str(block3usd))
    table.add_row(str(block4hex), str(block4btc), str(block4usd))
    table.add_row(str(blockhex_6), str(blockbtc_6), str(blockusd_6))
    table.add_row(str(blockhex_7), str(blockbtc_7), str(blockusd_7))
    table.add_row(str(blockhex_8), str(blockbtc_8), str(blockusd_8))
    table.add_row(str(blockhex_9), str(blockbtc_9), str(blockusd_9))
    table.add_row(str(blockhex_10), str(blockbtc_10), str(blockusd_10))
    table.add_row(str(blockhex_11), str(blockbtc_11), str(blockusd_11))
    table.add_row(str(blockhex_12), str(blockbtc_12), str(blockusd_12))
    table.add_row(str(blockhex_13), str(blockbtc_13), str(blockusd_13))
    table.add_row(str(blockhex_14), str(blockbtc_14), str(blockusd_14))
    table.add_row(str(blockhex_15), str(blockbtc_15), str(blockusd_15))
    table.add_row(str(blockhex_16), str(blockbtc_16), str(blockusd_16))
    table.add_row(str(blockhex_17), str(blockbtc_17), str(blockusd_17))
    table.add_row(str(blockhex_18), str(blockbtc_18), str(blockusd_18))
    table.add_row(str(blockhex_19), str(blockbtc_19), str(blockusd_19))
    table.add_row(str(blockhex_20), str(blockbtc_20), str(blockusd_20))


    def process_data():
        time.sleep(0.1)


    for _ in track(range(90), style="gold1 blink2", description='[gold1 blink2]Send Requests\n'):
        process_data()

    console = Console()
    console.print(table)
  # ============================
    continue


# ================================================
# DONATE (BTC) : 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
# Website : Mmdrza.Com
# Email : X4@mmdrza.Com
# Dev.to/Mmdrza
# Github.com/Pymmdrza
# ================================================

source code bitcoin transaction all report

2 Contract Token TRC20 TRON TRX

MMDRZA — Tue, 15 Mar 2022 20:00:45 +0000

TRON Smart Contract Single File :

Single2.sol Contract (TRC20 TRON):

Contract Name : SingleToken

Optimizartion : NO

Compiler Version : Solidity 0.5.4

License : None

All Funcation Single2.sol :

1.approve

2.transferFrom

3.increaseAllowance

4.decreaseAllowance

`5.transfer`

/*
*  __  __               _
* |  \/  |_ __ ___   __| |_ __ ______ _
* | |\/| | '_ ` _ \ / _` | '__|_  / _` |
* | |  | | | | | | | (_| | |   / / (_| |
* |_|  |_|_| |_| |_|\__,_|_|  /___\__,_|
*
* Programmer Mmdrza
* Web Mmdrza.Com
* Email X4@Mmdrza.Com
* Dev.to/Mmdrza
* Github.Com/Pymmdrza
* 
* /////////////////////////////
* Optimization: [No]
* License: [None]
* Compiler version: [solidity 0.5.4]
* Network: [TRC20 - ERC20 ]
*//////////////////////////////


pragma solidity ^0.5.4;


interface IERC20 {
    function totalSupply() external view returns (uint);
    function balanceOf(address account) external view returns (uint);
    function transfer(address recipient, uint amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
}

contract Context {
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }
}

contract ERC20 is Context, IERC20 {
    using SafeMath for uint;

    mapping (address => uint) public _balances;

    mapping (address => mapping (address => uint)) private _allowances;

    uint private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor (string memory name, string memory symbol, uint8 decimals, uint totalSupply) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
        _totalSupply = totalSupply;
    }
    function name() public view returns (string memory) {
        return _name;
    }
    function symbol() public view returns (string memory) {
        return _symbol;
    }
    function decimals() public view returns (uint8) {
        return _decimals;
    }


    function totalSupply() public view returns (uint) {
        return _totalSupply;
    }
    function balanceOf(address account) public view returns (uint) {
        return _balances[account];
    }
    function transfer(address recipient, uint amount) public returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }
    function allowance(address owner, address spender) public view returns (uint) {
        return _allowances[owner][spender];
    }
    function approve(address spender, uint amount) public returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }
    function transferFrom(address sender, address recipient, uint amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }
    function increaseAllowance(address spender, uint addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }
    function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }
    function _transfer(address sender, address recipient, uint amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _burn(address account, uint amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }
    function _approve(address owner, address spender, uint amount) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
}


library SafeMath {
    function add(uint a, uint b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }
    function sub(uint a, uint b) internal pure returns (uint) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }
    function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        require(b <= a, errorMessage);
        uint c = a - b;

        return c;
    }
    function mul(uint a, uint b) internal pure returns (uint) {
        if (a == 0) {
            return 0;
        }

        uint c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }
    function div(uint a, uint b) internal pure returns (uint) {
        return div(a, b, "SafeMath: division by zero");
    }
    function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint c = a / b;

        return c;
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }
}

library SafeERC20 {
    using SafeMath for uint;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint value) internal {
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

contract SingleToken is ERC20 {
  using SafeERC20 for IERC20;
  using Address for address;
  using SafeMath for uint;


  constructor () public ERC20("SingleToken1", "SNG1", 18, 1022000000*10**18) {
       _balances[msg.sender] = totalSupply();
        emit Transfer(address(0), msg.sender, totalSupply());
  }


}




*/
* =========================[M M D Z A . C o M]==============================
* Programmer M M D R Z A 
* Web Mmdrza.Com
* Dev.to/Mmdrza
* Github.Com/Pymmdrza
* Donate = Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
* =========================[M M D Z A . C o M]========================
*/

SingleContract/XADEREUM.sol :

Contract Name:Token

Optimization: Yes with 0 runs

Compiler version: solidity 0.5.10

License: None

All Funcation XADEREUM.sol :

1.Approve

2.Remove WhiteList

3.Transfer From

4.increase Allowance

5.BURN

6.Withdraw Token

7.Decrease Allowance

8.Transfer

9.Add WhiteList

`10.Transfer Ownership`

pragma solidity ^0.5.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}


/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20Mintable}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => bool) private _whiteList;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    address public fund; 

    address public owner; 

    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        owner = newOwner;
    }

    function addWhiteList(address user) public onlyOwner returns(bool){
        _whiteList[user] =true;
        return true;
    }

    function removeWhiteList(address user) public onlyOwner returns(bool){
        _whiteList[user] =false;
        return true;
    }

    function withdrawToken(IERC20 t,uint256 amount) public onlyOwner returns(bool){
        t.transfer(msg.sender,amount);
        return true;
    }

    function isInWhiteList(address user) public view returns(bool){
        return _whiteList[user];
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address user, address spender) public view returns (uint256) {
        return _allowances[user][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `value`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        if(_whiteList[sender] || _whiteList[recipient]){
            _transferNofee(sender, recipient, amount);
        }else{
            _transferfee(sender, recipient, amount);
        }
    }

    function _transferNofee(address sender, address recipient, uint256 amount) internal returns (bool) {
        _balances[sender] = _balances[sender].sub(amount);
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _transferfee(address sender, address recipient, uint256 amount) internal returns (bool) {
        _balances[sender] = _balances[sender].sub(amount.mul(95).div(100));
        _balances[recipient] = _balances[recipient].add(amount.mul(94).div(100));
        _balances[fund] = _balances[fund].add(amount.div(100));
        _burn(sender,amount.div(20));
        emit Transfer(sender, recipient, amount.mul(95).div(100));
        emit Transfer(sender, fund, amount.div(100));
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

     /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 value) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }

    function burn(uint256 value) public returns (bool){
        _burn(msg.sender, value);
        return true;
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address user, address spender, uint256 value) internal {
        require(user != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[user][spender] = value;
        emit Approval(user, spender, value);
    }

    /**
     * @dev Destoys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
    }
}


/**
 * @dev Optional functions from the ERC20 standard.
 */
contract ERC20Detailed is IERC20 {
    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
     * these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol, uint8 decimals) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }
}




contract Token is ERC20, ERC20Detailed {

    /**
     * @dev Constructor that gives msg.sender all of existing tokens.
     */
    constructor () public ERC20Detailed("XADEREUM", "XAD", 6) {
   // here inser your hex address base58 
        fund = address(0x41e1926c34dce99e443929dc62adc79f3cdae9f872);
        owner = msg.sender;
        _mint(owner, 21000000 * (10 ** uint256(decimals())));
    }
}

Contact Me x4@Mmdrza.Com

🔰Donate :

🔰BTC ADD:
16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8

🔰USDT TRC20:
TSb4w985WJ2zdDtTvex6jjFLejqZHGK5ez

2 Contract Single file TRC20 TRON For Create Token

MMDRZA — Tue, 15 Mar 2022 19:59:37 +0000

TRON Smart Contract Single File :

Single2.sol Contract (TRC20 TRON):

Contract Name : SingleToken

Optimizartion : NO

Compiler Version : Solidity 0.5.4

License : None

All Funcation Single2.sol :

1.approve

2.transferFrom

3.increaseAllowance

4.decreaseAllowance

`5.transfer`

/*
*  __  __               _
* |  \/  |_ __ ___   __| |_ __ ______ _
* | |\/| | '_ ` _ \ / _` | '__|_  / _` |
* | |  | | | | | | | (_| | |   / / (_| |
* |_|  |_|_| |_| |_|\__,_|_|  /___\__,_|
*
* Programmer Mmdrza
* Web Mmdrza.Com
* Email X4@Mmdrza.Com
* Dev.to/Mmdrza
* Github.Com/Pymmdrza
* 
* /////////////////////////////
* Optimization: [No]
* License: [None]
* Compiler version: [solidity 0.5.4]
* Network: [TRC20 - ERC20 ]
*//////////////////////////////


pragma solidity ^0.5.4;


interface IERC20 {
    function totalSupply() external view returns (uint);
    function balanceOf(address account) external view returns (uint);
    function transfer(address recipient, uint amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
}

contract Context {
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }
}

contract ERC20 is Context, IERC20 {
    using SafeMath for uint;

    mapping (address => uint) public _balances;

    mapping (address => mapping (address => uint)) private _allowances;

    uint private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor (string memory name, string memory symbol, uint8 decimals, uint totalSupply) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
        _totalSupply = totalSupply;
    }
    function name() public view returns (string memory) {
        return _name;
    }
    function symbol() public view returns (string memory) {
        return _symbol;
    }
    function decimals() public view returns (uint8) {
        return _decimals;
    }


    function totalSupply() public view returns (uint) {
        return _totalSupply;
    }
    function balanceOf(address account) public view returns (uint) {
        return _balances[account];
    }
    function transfer(address recipient, uint amount) public returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }
    function allowance(address owner, address spender) public view returns (uint) {
        return _allowances[owner][spender];
    }
    function approve(address spender, uint amount) public returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }
    function transferFrom(address sender, address recipient, uint amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }
    function increaseAllowance(address spender, uint addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }
    function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }
    function _transfer(address sender, address recipient, uint amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _burn(address account, uint amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }
    function _approve(address owner, address spender, uint amount) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
}


library SafeMath {
    function add(uint a, uint b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }
    function sub(uint a, uint b) internal pure returns (uint) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }
    function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        require(b <= a, errorMessage);
        uint c = a - b;

        return c;
    }
    function mul(uint a, uint b) internal pure returns (uint) {
        if (a == 0) {
            return 0;
        }

        uint c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }
    function div(uint a, uint b) internal pure returns (uint) {
        return div(a, b, "SafeMath: division by zero");
    }
    function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint c = a / b;

        return c;
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }
}

library SafeERC20 {
    using SafeMath for uint;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint value) internal {
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

contract SingleToken is ERC20 {
  using SafeERC20 for IERC20;
  using Address for address;
  using SafeMath for uint;


  constructor () public ERC20("SingleToken1", "SNG1", 18, 1022000000*10**18) {
       _balances[msg.sender] = totalSupply();
        emit Transfer(address(0), msg.sender, totalSupply());
  }


}




*/
* =========================[M M D Z A . C o M]==============================
* Programmer M M D R Z A 
* Web Mmdrza.Com
* Dev.to/Mmdrza
* Github.Com/Pymmdrza
* Donate = Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
* =========================[M M D Z A . C o M]========================
*/

SingleContract/XADEREUM.sol :

Contract Name:Token

Optimization: Yes with 0 runs

Compiler version: solidity 0.5.10

License: None

All Funcation XADEREUM.sol :

1.Approve

2.Remove WhiteList

3.Transfer From

4.increase Allowance

5.BURN

6.Withdraw Token

7.Decrease Allowance

8.Transfer

9.Add WhiteList

`10.Transfer Ownership`

pragma solidity ^0.5.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}


/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20Mintable}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => bool) private _whiteList;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    address public fund; 

    address public owner; 

    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        owner = newOwner;
    }

    function addWhiteList(address user) public onlyOwner returns(bool){
        _whiteList[user] =true;
        return true;
    }

    function removeWhiteList(address user) public onlyOwner returns(bool){
        _whiteList[user] =false;
        return true;
    }

    function withdrawToken(IERC20 t,uint256 amount) public onlyOwner returns(bool){
        t.transfer(msg.sender,amount);
        return true;
    }

    function isInWhiteList(address user) public view returns(bool){
        return _whiteList[user];
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address user, address spender) public view returns (uint256) {
        return _allowances[user][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `value`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        if(_whiteList[sender] || _whiteList[recipient]){
            _transferNofee(sender, recipient, amount);
        }else{
            _transferfee(sender, recipient, amount);
        }
    }

    function _transferNofee(address sender, address recipient, uint256 amount) internal returns (bool) {
        _balances[sender] = _balances[sender].sub(amount);
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _transferfee(address sender, address recipient, uint256 amount) internal returns (bool) {
        _balances[sender] = _balances[sender].sub(amount.mul(95).div(100));
        _balances[recipient] = _balances[recipient].add(amount.mul(94).div(100));
        _balances[fund] = _balances[fund].add(amount.div(100));
        _burn(sender,amount.div(20));
        emit Transfer(sender, recipient, amount.mul(95).div(100));
        emit Transfer(sender, fund, amount.div(100));
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

     /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 value) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }

    function burn(uint256 value) public returns (bool){
        _burn(msg.sender, value);
        return true;
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address user, address spender, uint256 value) internal {
        require(user != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[user][spender] = value;
        emit Approval(user, spender, value);
    }

    /**
     * @dev Destoys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
    }
}


/**
 * @dev Optional functions from the ERC20 standard.
 */
contract ERC20Detailed is IERC20 {
    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
     * these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol, uint8 decimals) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }
}




contract Token is ERC20, ERC20Detailed {

    /**
     * @dev Constructor that gives msg.sender all of existing tokens.
     */
    constructor () public ERC20Detailed("XADEREUM", "XAD", 6) {
   // here inser your hex address base58 
        fund = address(0x41e1926c34dce99e443929dc62adc79f3cdae9f872);
        owner = msg.sender;
        _mint(owner, 21000000 * (10 ** uint256(decimals())));
    }
}

Contact Me x4@Mmdrza.Com

🔰Donate :

🔰BTC ADD:
16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8

🔰USDT TRC20:
TSb4w985WJ2zdDtTvex6jjFLejqZHGK5ez

Bitcoin Address and PrivateKey Generator With Python and Check Balance

MMDRZA — Tue, 15 Mar 2022 16:30:05 +0000

Bitcoin address and Private key search and generator with check balance without apikey
first install this package :
pip install hdwallet
pip install bs4

after install package's use this source :

import time

from hdwallet import HDWallet
from hdwallet.symbols import ETH as SYMBOL
import random
from bs4 import BeautifulSoup
import requests

mmdrza = '''
=========================[MMDZA.CoM]==============================
|            _ __ ___  _ __ ___   __| |_ __ ______ _             | 
|           | '_ ` _ \| '_ ` _ \ / _` | '__|_  / _` |            |
|           | | | | | | | | | | | (_| | |   / / (_| |            |
|           |_| |_| |_|_| |_| |_|\__,_|_|  /___\__,_|            |
=========================[MMDZA.CoM]==============================
= Athur : MMDRZA
= Email : x4@Mmdrza.Com
= Web : https://Mmdrza.Com
= Dev.to/mmdrza
= Github.Com/Pymmdrza
=========================[MMDZA.CoM]==============================
|| Donate =    Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8       ||
=========================[MMDZA.CoM]==============================
        '''

print(mmdrza)
print('===[Follow My Web Site Mmdrza.Com and Enjoy All Source Python]===')
time.sleep(5)
z = 1
# =========================[MMDZA.CoM]==============================


while True:
    c1 = str(random.choice('0123456789abcdefABCDEF'))
    c2 = str(random.choice('0123456789abcdefABCDEF'))
    c3 = str(random.choice('0123456789abcdefABCDEF'))
    c4 = str(random.choice('0123456789abcdefABCDEF'))
    c5 = str(random.choice('0123456789abcdefABCDEF'))
    c6 = str(random.choice('0123456789abcdefABCDEF'))
    c7 = str(random.choice('0123456789abcdefABCDEF'))
    c8 = str(random.choice('0123456789abcdefABCDEF'))
    c9 = str(random.choice('0123456789abcdefABCDEF'))
    c10 = str(random.choice('0123456789abcdefABCDEF'))
    c11 = str(random.choice('0123456789abcdefABCDEF'))
    c12 = str(random.choice('0123456789abcdefABCDEF'))
    c13 = str(random.choice('0123456789abcdefABCDEF'))
    c14 = str(random.choice('0123456789abcdefABCDEF'))
    c15 = str(random.choice('0123456789abcdefABCDEF'))
    c16 = str(random.choice('0123456789abcdefABCDEF'))
    c17 = str(random.choice('0123456789abcdefABCDEF'))
    c18 = str(random.choice('0123456789abcdefABCDEF'))
    c19 = str(random.choice('0123456789abcdefABCDEF'))
    c20 = str(random.choice('0123456789abcdefABCDEF'))
    c21 = str(random.choice('0123456789abcdefABCDEF'))
    c22 = str(random.choice('0123456789abcdefABCDEF'))
    c23 = str(random.choice('0123456789abcdefABCDEF'))
    c24 = str(random.choice('0123456789abcdefABCDEF'))
    c25 = str(random.choice('0123456789abcdefABCDEF'))
    c26 = str(random.choice('0123456789abcdefABCDEF'))
    c27 = str(random.choice('0123456789abcdefABCDEF'))
    c28 = str(random.choice('0123456789abcdefABCDEF'))
    c29 = str(random.choice('0123456789abcdefABCDEF'))
    c30 = str(random.choice('0123456789abcdefABCDEF'))
    c31 = str(random.choice('0123456789abcdefABCDEF'))
    c32 = str(random.choice('0123456789abcdefABCDEF'))
    c33 = str(random.choice('0123456789abcdefABCDEF'))
    c34 = str(random.choice('0123456789abcdefABCDEF'))
    c35 = str(random.choice('0123456789abcdefABCDEF'))
    c36 = str(random.choice('0123456789abcdefABCDEF'))
    c37 = str(random.choice('0123456789abcdefABCDEF'))
    c38 = str(random.choice('0123456789abcdefABCDEF'))
    c39 = str(random.choice('0123456789abcdefABCDEF'))
    c40 = str(random.choice('0123456789abcdefABCDEF'))
    c41 = str(random.choice('0123456789abcdefABCDEF'))
    c42 = str(random.choice('0123456789abcdefABCDEF'))
    c43 = str(random.choice('0123456789abcdefABCDEF'))
    c44 = str(random.choice('0123456789abcdefABCDEF'))
    c45 = str(random.choice('0123456789abcdefABCDEF'))
    c46 = str(random.choice('0123456789abcdefABCDEF'))
    c47 = str(random.choice('0123456789abcdefABCDEF'))
    c48 = str(random.choice('0123456789abcdefABCDEF'))
    c49 = str(random.choice('0123456789abcdefABCDEF'))
    c50 = str(random.choice('0123456789abcdefABCDEF'))
    c51 = str(random.choice('0123456789abcdefABCDEF'))
    c52 = str(random.choice('0123456789abcdefABCDEF'))
    c53 = str(random.choice('0123456789abcdefABCDEF'))
    c54 = str(random.choice('0123456789abcdefABCDEF'))
    c55 = str(random.choice('0123456789abcdefABCDEF'))
    c56 = str(random.choice('0123456789abcdefABCDEF'))
    c57 = str(random.choice('0123456789abcdefABCDEF'))
    c58 = str(random.choice('0123456789abcdefABCDEF'))
    c59 = str(random.choice('0123456789abcdefABCDEF'))
    c60 = str(random.choice('0123456789abcdefABCDEF'))
    c61 = str(random.choice('0123456789abcdefABCDEF'))
    c62 = str(random.choice('0123456789abcdefABCDEF'))
    c63 = str(random.choice('0123456789abcdefABCDEF'))
    c64 = str(random.choice('0123456789abcdefABCDEF'))
    magic = (
            c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 + c12 + c13 + c14 + c15 + c16 + c17 + c18 + c19 + c20 + c21 + c22 + c23 + c24 + c25 + c26 + c27 + c28 + c29 + c30 + c31 + c32 + c33 + c34 + c35 + c36 + c37 + c38 + c39 + c40 + c41 + c42 + c43 + c44 + c45 + c46 + c47 + c48 + c49 + c50 + c51 + c52 + c53 + c54 + c55 + c56 + c57 + c58 + c59 + c60 + c61 + c62 + c63 + c64)
    PRIVATE_KEY = str(magic)
    # =========================[MMDZA.CoM]==============================
    hdwallet: HDWallet = HDWallet(symbol=SYMBOL)
    hdwallet.from_private_key(private_key=PRIVATE_KEY)
    privatekey = hdwallet.private_key()
    btcaddr1 = hdwallet.p2sh_address()
    # =========================[MMDZA.CoM]==============================
    URL = ('https://bitcoin.atomicwallet.io/address/' + btcaddr1)
    markup = "<h1></h1>"
    headers = {
        "User-Agent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537'}
    page = requests.get(URL, headers=headers)
    soup = BeautifulSoup(page.content, 'html.parser')
    small = soup.find("small", {"class": 'text-muted'}).get_text()
    rnd = str(small)[:2]
    # =========================[MMDZA.CoM]==============================
    print(str(z), 'ADD=', str(btcaddr1), str(rnd), '[ MMDRZA.CoM ]')
    z += 1
    # =========================[MMDZA.CoM]==============================
    if int(rnd) > 0:
        print('=======================[ M M D R Z A . C o M ]=======================')
        print('Save information pivatekey and balance on the btcWallet.txt ')
        print('=======================[ M M D R Z A . C o M ]=======================')
        f = open("btcWallet.txt", "a")
        f.write(privatekey + '\n')
        f.write(btcaddr1 + '  BAL= ' + rnd + '\n')
        f.write('=======================[ M M D R Z A . C o M ]=======================')
        f.write('Donate (BTC) = 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8')
        f.write('=======================[ M M D R Z A . C o M ]=======================')
        f.close()
        # =========================[MMDZA.CoM]==============================
        continue

# =========================[M M D Z A . C o M]==============================
# Programmer M M D R Z A
# Web Mmdrza.Com
# Dev.to/Mmdrza
# Github.Com/Pymmdrza
# Donat = Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
# =========================[M M D Z A . C o M]==============================

Visit Another Source : MMDRZA.COM

# =========================[M M D Z A . C o M]==============================
# Programmer M M D R Z A
# Web Mmdrza.Com
# Dev.to/Mmdrza
# Github.Com/Pymmdrza
# Donat = Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
# =========================[M M D Z A . C o M]==============================

Bitcoin Generator All Address Type

MMDRZA — Tue, 15 Mar 2022 16:28:41 +0000

Bitcoin address and Private key search and generator with check balance without apikey
first install this package :
pip install hdwallet
pip install bs4

after install package's use this source :

import time

from hdwallet import HDWallet
from hdwallet.symbols import ETH as SYMBOL
import random
from bs4 import BeautifulSoup
import requests

mmdrza = '''
=========================[MMDZA.CoM]==============================
|            _ __ ___  _ __ ___   __| |_ __ ______ _             | 
|           | '_ ` _ \| '_ ` _ \ / _` | '__|_  / _` |            |
|           | | | | | | | | | | | (_| | |   / / (_| |            |
|           |_| |_| |_|_| |_| |_|\__,_|_|  /___\__,_|            |
=========================[MMDZA.CoM]==============================
= Athur : MMDRZA
= Email : x4@Mmdrza.Com
= Web : https://Mmdrza.Com
= Dev.to/mmdrza
= Github.Com/Pymmdrza
=========================[MMDZA.CoM]==============================
|| Donate =    Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8       ||
=========================[MMDZA.CoM]==============================
        '''

print(mmdrza)
print('===[Follow My Web Site Mmdrza.Com and Enjoy All Source Python]===')
time.sleep(5)
z = 1
# =========================[MMDZA.CoM]==============================


while True:
    c1 = str(random.choice('0123456789abcdefABCDEF'))
    c2 = str(random.choice('0123456789abcdefABCDEF'))
    c3 = str(random.choice('0123456789abcdefABCDEF'))
    c4 = str(random.choice('0123456789abcdefABCDEF'))
    c5 = str(random.choice('0123456789abcdefABCDEF'))
    c6 = str(random.choice('0123456789abcdefABCDEF'))
    c7 = str(random.choice('0123456789abcdefABCDEF'))
    c8 = str(random.choice('0123456789abcdefABCDEF'))
    c9 = str(random.choice('0123456789abcdefABCDEF'))
    c10 = str(random.choice('0123456789abcdefABCDEF'))
    c11 = str(random.choice('0123456789abcdefABCDEF'))
    c12 = str(random.choice('0123456789abcdefABCDEF'))
    c13 = str(random.choice('0123456789abcdefABCDEF'))
    c14 = str(random.choice('0123456789abcdefABCDEF'))
    c15 = str(random.choice('0123456789abcdefABCDEF'))
    c16 = str(random.choice('0123456789abcdefABCDEF'))
    c17 = str(random.choice('0123456789abcdefABCDEF'))
    c18 = str(random.choice('0123456789abcdefABCDEF'))
    c19 = str(random.choice('0123456789abcdefABCDEF'))
    c20 = str(random.choice('0123456789abcdefABCDEF'))
    c21 = str(random.choice('0123456789abcdefABCDEF'))
    c22 = str(random.choice('0123456789abcdefABCDEF'))
    c23 = str(random.choice('0123456789abcdefABCDEF'))
    c24 = str(random.choice('0123456789abcdefABCDEF'))
    c25 = str(random.choice('0123456789abcdefABCDEF'))
    c26 = str(random.choice('0123456789abcdefABCDEF'))
    c27 = str(random.choice('0123456789abcdefABCDEF'))
    c28 = str(random.choice('0123456789abcdefABCDEF'))
    c29 = str(random.choice('0123456789abcdefABCDEF'))
    c30 = str(random.choice('0123456789abcdefABCDEF'))
    c31 = str(random.choice('0123456789abcdefABCDEF'))
    c32 = str(random.choice('0123456789abcdefABCDEF'))
    c33 = str(random.choice('0123456789abcdefABCDEF'))
    c34 = str(random.choice('0123456789abcdefABCDEF'))
    c35 = str(random.choice('0123456789abcdefABCDEF'))
    c36 = str(random.choice('0123456789abcdefABCDEF'))
    c37 = str(random.choice('0123456789abcdefABCDEF'))
    c38 = str(random.choice('0123456789abcdefABCDEF'))
    c39 = str(random.choice('0123456789abcdefABCDEF'))
    c40 = str(random.choice('0123456789abcdefABCDEF'))
    c41 = str(random.choice('0123456789abcdefABCDEF'))
    c42 = str(random.choice('0123456789abcdefABCDEF'))
    c43 = str(random.choice('0123456789abcdefABCDEF'))
    c44 = str(random.choice('0123456789abcdefABCDEF'))
    c45 = str(random.choice('0123456789abcdefABCDEF'))
    c46 = str(random.choice('0123456789abcdefABCDEF'))
    c47 = str(random.choice('0123456789abcdefABCDEF'))
    c48 = str(random.choice('0123456789abcdefABCDEF'))
    c49 = str(random.choice('0123456789abcdefABCDEF'))
    c50 = str(random.choice('0123456789abcdefABCDEF'))
    c51 = str(random.choice('0123456789abcdefABCDEF'))
    c52 = str(random.choice('0123456789abcdefABCDEF'))
    c53 = str(random.choice('0123456789abcdefABCDEF'))
    c54 = str(random.choice('0123456789abcdefABCDEF'))
    c55 = str(random.choice('0123456789abcdefABCDEF'))
    c56 = str(random.choice('0123456789abcdefABCDEF'))
    c57 = str(random.choice('0123456789abcdefABCDEF'))
    c58 = str(random.choice('0123456789abcdefABCDEF'))
    c59 = str(random.choice('0123456789abcdefABCDEF'))
    c60 = str(random.choice('0123456789abcdefABCDEF'))
    c61 = str(random.choice('0123456789abcdefABCDEF'))
    c62 = str(random.choice('0123456789abcdefABCDEF'))
    c63 = str(random.choice('0123456789abcdefABCDEF'))
    c64 = str(random.choice('0123456789abcdefABCDEF'))
    magic = (
            c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 + c12 + c13 + c14 + c15 + c16 + c17 + c18 + c19 + c20 + c21 + c22 + c23 + c24 + c25 + c26 + c27 + c28 + c29 + c30 + c31 + c32 + c33 + c34 + c35 + c36 + c37 + c38 + c39 + c40 + c41 + c42 + c43 + c44 + c45 + c46 + c47 + c48 + c49 + c50 + c51 + c52 + c53 + c54 + c55 + c56 + c57 + c58 + c59 + c60 + c61 + c62 + c63 + c64)
    PRIVATE_KEY = str(magic)
    # =========================[MMDZA.CoM]==============================
    hdwallet: HDWallet = HDWallet(symbol=SYMBOL)
    hdwallet.from_private_key(private_key=PRIVATE_KEY)
    privatekey = hdwallet.private_key()
    btcaddr1 = hdwallet.p2sh_address()
    # =========================[MMDZA.CoM]==============================
    URL = ('https://bitcoin.atomicwallet.io/address/' + btcaddr1)
    markup = "<h1></h1>"
    headers = {
        "User-Agent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537'}
    page = requests.get(URL, headers=headers)
    soup = BeautifulSoup(page.content, 'html.parser')
    small = soup.find("small", {"class": 'text-muted'}).get_text()
    rnd = str(small)[:2]
    # =========================[MMDZA.CoM]==============================
    print(str(z), 'ADD=', str(btcaddr1), str(rnd), '[ MMDRZA.CoM ]')
    z += 1
    # =========================[MMDZA.CoM]==============================
    if int(rnd) > 0:
        print('=======================[ M M D R Z A . C o M ]=======================')
        print('Save information pivatekey and balance on the btcWallet.txt ')
        print('=======================[ M M D R Z A . C o M ]=======================')
        f = open("btcWallet.txt", "a")
        f.write(privatekey + '\n')
        f.write(btcaddr1 + '  BAL= ' + rnd + '\n')
        f.write('=======================[ M M D R Z A . C o M ]=======================')
        f.write('Donate (BTC) = 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8')
        f.write('=======================[ M M D R Z A . C o M ]=======================')
        f.close()
        # =========================[MMDZA.CoM]==============================
        continue

# =========================[M M D Z A . C o M]==============================
# Programmer M M D R Z A
# Web Mmdrza.Com
# Dev.to/Mmdrza
# Github.Com/Pymmdrza
# Donat = Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
# =========================[M M D Z A . C o M]==============================

Visit Another Source : MMDRZA.COM

# =========================[M M D Z A . C o M]==============================
# Programmer M M D R Z A
# Web Mmdrza.Com
# Dev.to/Mmdrza
# Github.Com/Pymmdrza
# Donat = Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
# =========================[M M D Z A . C o M]==============================

Ethereum and BNB Wallet Generator , Balance Check

MMDRZA — Tue, 15 Mar 2022 11:19:41 +0000

Ethereum Wallet Address and Private Key Generated With Python And Check Balance On ethersan and BSCscan With APIKEY :
First install This Package On CMD or Terminal
pip install colorama
pip install hdwallet
for apikey follow this site :
Etherscan (ETHEREUM)
BNB(BSC)

mmdrza = '''

=========================[M M D Z A . C o M]==============================
             _ __ ___  _ __ ___   __| |_ __ ______ _
            | '_ ` _ \| '_ ` _ \ / _` | '__|_  / _` |
            | | | | | | | | | | | (_| | |   / / (_| |
            |_| |_| |_|_| |_| |_|\__,_|_|  /___\__,_|
=========================[M M D Z A . C o M]==============================
= Athur : MMDRZA
= Email : x4@Mmdrza.Com
= Web : https://Mmdrza.Com
= Dev.to/mmdrza
= Github.Com/Pymmdrza
=========================[M M D Z A . C o M]==============================
= Donat = Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
=========================[M M D Z A . C o M]==============================
        '''

from hdwallet import HDWallet
from hdwallet.symbols import ETH as SYMBOL
import random
import requests
import json
from colorama import Fore, Style
import time

# =========================[M M D Z A . C o M]==============================
print(Fore.GREEN,mmdrza,Style.RESET_ALL)
print('Start ...')
time.sleep(5)
# =========================[M M D Z A . C o M]==============================
z = 1
while True:
    c1 = str(random.choice('0123456789abcdefABCDEF'))
    c2 = str(random.choice('0123456789abcdefABCDEF'))
    c3 = str(random.choice('0123456789abcdefABCDEF'))
    c4 = str(random.choice('0123456789abcdefABCDEF'))
    c5 = str(random.choice('0123456789abcdefABCDEF'))
    c6 = str(random.choice('0123456789abcdefABCDEF'))
    c7 = str(random.choice('0123456789abcdefABCDEF'))
    c8 = str(random.choice('0123456789abcdefABCDEF'))
    c9 = str(random.choice('0123456789abcdefABCDEF'))
    c10 = str(random.choice('0123456789abcdefABCDEF'))
    c11 = str(random.choice('0123456789abcdefABCDEF'))
    c12 = str(random.choice('0123456789abcdefABCDEF'))
    c13 = str(random.choice('0123456789abcdefABCDEF'))
    c14 = str(random.choice('0123456789abcdefABCDEF'))
    c15 = str(random.choice('0123456789abcdefABCDEF'))
    c16 = str(random.choice('0123456789abcdefABCDEF'))
    c17 = str(random.choice('0123456789abcdefABCDEF'))
    c18 = str(random.choice('0123456789abcdefABCDEF'))
    c19 = str(random.choice('0123456789abcdefABCDEF'))
    c20 = str(random.choice('0123456789abcdefABCDEF'))
    c21 = str(random.choice('0123456789abcdefABCDEF'))
    c22 = str(random.choice('0123456789abcdefABCDEF'))
    c23 = str(random.choice('0123456789abcdefABCDEF'))
    c24 = str(random.choice('0123456789abcdefABCDEF'))
    c25 = str(random.choice('0123456789abcdefABCDEF'))
    c26 = str(random.choice('0123456789abcdefABCDEF'))
    c27 = str(random.choice('0123456789abcdefABCDEF'))
    c28 = str(random.choice('0123456789abcdefABCDEF'))
    c29 = str(random.choice('0123456789abcdefABCDEF'))
    c30 = str(random.choice('0123456789abcdefABCDEF'))
    c31 = str(random.choice('0123456789abcdefABCDEF'))
    c32 = str(random.choice('0123456789abcdefABCDEF'))
    c33 = str(random.choice('0123456789abcdefABCDEF'))
    c34 = str(random.choice('0123456789abcdefABCDEF'))
    c35 = str(random.choice('0123456789abcdefABCDEF'))
    c36 = str(random.choice('0123456789abcdefABCDEF'))
    c37 = str(random.choice('0123456789abcdefABCDEF'))
    c38 = str(random.choice('0123456789abcdefABCDEF'))
    c39 = str(random.choice('0123456789abcdefABCDEF'))
    c40 = str(random.choice('0123456789abcdefABCDEF'))
    c41 = str(random.choice('0123456789abcdefABCDEF'))
    c42 = str(random.choice('0123456789abcdefABCDEF'))
    c43 = str(random.choice('0123456789abcdefABCDEF'))
    c44 = str(random.choice('0123456789abcdefABCDEF'))
    c45 = str(random.choice('0123456789abcdefABCDEF'))
    c46 = str(random.choice('0123456789abcdefABCDEF'))
    c47 = str(random.choice('0123456789abcdefABCDEF'))
    c48 = str(random.choice('0123456789abcdefABCDEF'))
    c49 = str(random.choice('0123456789abcdefABCDEF'))
    c50 = str(random.choice('0123456789abcdefABCDEF'))
    c51 = str(random.choice('0123456789abcdefABCDEF'))
    c52 = str(random.choice('0123456789abcdefABCDEF'))
    c53 = str(random.choice('0123456789abcdefABCDEF'))
    c54 = str(random.choice('0123456789abcdefABCDEF'))
    c55 = str(random.choice('0123456789abcdefABCDEF'))
    c56 = str(random.choice('0123456789abcdefABCDEF'))
    c57 = str(random.choice('0123456789abcdefABCDEF'))
    c58 = str(random.choice('0123456789abcdefABCDEF'))
    c59 = str(random.choice('0123456789abcdefABCDEF'))
    c60 = str(random.choice('0123456789abcdefABCDEF'))
    c61 = str(random.choice('0123456789abcdefABCDEF'))
    c62 = str(random.choice('0123456789abcdefABCDEF'))
    c63 = str(random.choice('0123456789abcdefABCDEF'))
    c64 = str(random.choice('0123456789abcdefABCDEF'))
    magic = (c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 + c12 + c13 + c14 + c15 + c16 + c17 + c18 + c19 + c20 + c21 + c22 + c23 + c24 + c25 + c26 + c27 + c28 + c29 + c30 + c31 + c32 + c33 + c34 + c35 + c36 + c37 + c38 + c39 + c40 + c41 + c42 + c43 + c44 + c45 + c46 + c47 + c48 + c49 + c50 + c51 + c52 + c53 + c54 + c55 + c56 + c57 + c58 + c59 + c60 + c61 + c62 + c63 + c64)
    # Start API
    # =========================[M M D Z A . C o M]==============================
    api1 = "&apikey=ENTER-YOUR-API-EtherScan.iO"
    api2 = "&apikey=ENTER-YOUR-API-EtherScan.iO"
    api3 = "&apiKey=ENTER-YOUR-API-EtherScan.iO"
    api4 = "&apiKey=ENTER-YOUR-API-EtherScan.iO"
    api5 = "&apiKey=ENTER-YOUR-API-EtherScan.iO"
    api6 = "&apiKey=ENTER-YOUR-API-EtherScan.iO"
    api7 = "&apiKey=ENTER-YOUR-API-EtherScan.iO"
    api8 = "&apiKey=ENTER-YOUR-API-EtherScan.iO"
    api9 = "&apiKey=ENTER-YOUR-API-EtherScan.iO"
    api10 = "&apiKey=ENTER-YOUR-API-EtherScan.iO"
    api11 = "&apiKey=UYUY9G3NBU8RU89D3SAREY9Q92BV31IC56"
    api12 = "&apiKey=FH5MNBV4XZH6TU4E2VE8FH9FEBVW1VF61N"
    # =========================[M M D Z A . C o M]==============================
    bapi1 = "&apikey=ENTER-YOUR-API-BSCSCAN.iO"
    bapi2 = "&apikey=ENTER-YOUR-API-BSCSCAN.iO"
    bapi3 = "&apiKey=ENTER-YOUR-API-BSCSCAN.iO"
    bapi4 = "&apiKey=ENTER-YOUR-API-BSCSCAN.iO"
    bapi5 = "&apiKey=ENTER-YOUR-API-BSCSCAN.iO"
    bapi6 = "&apiKey=ENTER-YOUR-API-BSCSCAN.iO"
    mylist1 = [str(bapi1), str(bapi2), str(bapi3), str(bapi4), str(bapi5), str(bapi6)]
    apikeysbnb = random.choice(mylist1)
    # =======================[M M D Z A . C o M]================================
    mylist = [str(api1), str(api2), str(api3), str(api4), str(api10), str(api11), str(api12),str(api5), str(api6), str(api7), str(api8), str(api9)]
    # =========================[M M D Z A . C o M]==============================
    apikeys = random.choice(mylist)
    # =========================[M M D Z A . C o M]==============================
    PRIVATE_KEY = str(magic)
    hdwallet: HDWallet = HDWallet(symbol=SYMBOL)
    hdwallet.from_private_key(private_key=PRIVATE_KEY)
    privatekey = hdwallet.private_key()
    ethaddr = hdwallet.p2pkh_address()  # 0xEF3589b72bd2f2e539843aa0Af67FEd18906A761
    blocs = requests.get("https://api.etherscan.io/api?module=account&action=balance&address=" + ethaddr + apikeys)
    ress = blocs.json()
    baleth = dict(ress)["result"]
    blocs1 = requests.get("https://api.bscscan.com/api?module=account&action=balance&address=" + ethaddr + apikeysbnb)
    ress1 = blocs1.json()
    balbnb = dict(ress1)["result"]
    # =========================[M M D Z A . C o M]==============================
    print(str(z),Fore.YELLOW,'ADDR =',Fore.WHITE,str(ethaddr),Fore.YELLOW,'PRIV =',Fore.GREEN,str(privatekey),Fore.RED,'[ ETH=',str(baleth),'BNB=',str(balbnb),']')
    z += 1
    # =========================[M M D Z A . C o M]==============================
    if int(balbnb) or int(baleth) > 0:
        print('Win Wallet --------- Save On Text File --------')
        print('----------------------[M M D Z A . C o M]----------------------')
        print('Address =>', ethaddr)
        print('PrivateKey =>', privatekey)
        f = open("ETHxBNB.txt","a")
        f.write('\nAddress = ' + ethaddr)
        f.write('\nPrivate = ' + privatekey)
        f.write('\n===================================[M M D Z A . C o M]===================================')
        f.close()
        continue




# =========================[M M D Z A . C o M]==============================
# Programmer M M D R Z A 
# Web Mmdrza.Com
# Dev.to/Mmdrza
# Github.Com/Pymmdrza
# Donate = Bitcoin 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
# =========================[M M D Z A . C o M]==============================

For Run This Program On Windows:
python <filename>.py
Run On Linux :
python3 <filename>.py

DONATE with BTC 16p9y6EstGYcnofGNvUJMEGKiAWhAr1uR8
Programmer Website : Mmdrza.Com

Bitcoin Private Key Finder and Generator address , hack wallet with python

MMDRZA — Mon, 17 Jan 2022 02:40:22 +0000

Bitcoin Private Key Wallet Finder
Generator address and Private Key
Received input Range For user
use python 3.8 and Pycharm Professional , blockcypher , moneywagon urlib satoshi package for this project.

pip install blockcypher
pip install moneywagon
pip install urllib
pip install satoshi

after install all package create file utils.py for config and setting base program . you can visit my youtube channel and follow this project video ( title youtube on my channel ):

Bitcoin Private Key Finder and Generator Auto With Python.
youtu.be/0MvjIxy4vBQ

after create file utils.py on director base project first import this package from this python coding :

from hashlib import sha256
from typing import Union

after insert this package entered all cod on file utils.py :


class Point(object):
    def __init__(self, _x, _y, _order=None):
        self.x, self.y, self.order = _x, _y, _order

    def calc(self, top, bottom, other_x):
        ll = (top * inverse_mod(bottom)) % p
        x3 = (ll * ll - self.x - other_x) % p
        return Point(x3, (ll * (self.x - x3) - self.y) % p)

    def double(self):
        if self == INFINITY:
            return INFINITY
        return self.calc(3 * self.x * self.x, 2 * self.y, self.x)

    def __add__(self, other):
        if other == INFINITY:
            return self
        if self == INFINITY:
            return other
        if self.x == other.x:
            if (self.y + other.y) % p == 0:
                return INFINITY
            return self.double()
        return self.calc(other.y - self.y, other.x - self.x, other.x)

    def __mul__(self, e):
        if self.order:
            e %= self.order
        if e == 0 or self == INFINITY:
            return INFINITY
        result, q = INFINITY, self
        while e:
            if e & 1:
                result += q
            e, q = e >> 1, q.double()
        return result

    def __str__(self):
        if self == INFINITY:
            return "infinity"
        return "%x %x" % (self.x, self.y)


p, INFINITY = (
    0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F,
    Point(None, None),
)  # secp256k1
g = Point(
    0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
    0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
    0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141,
)


def inverse_mod(a):
    if a < 0 or a >= p:
        a = a % p
    c, d, uc, vc, ud, vd = a, p, 1, 0, 0, 1
    while c:
        q, c, d = divmod(d, c) + (c,)
        uc, vc, ud, vd = ud - q * uc, vd - q * vc, uc, vc
    if ud > 0:
        return ud
    return ud + p


BITCOIN_ALPHABET = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"


def scrub_input(v: Union[str, bytes]) -> bytes:
    if isinstance(v, str):
        v = v.encode("ascii")
    return v


def b58encode_int(
    i: int, default_one: bool = True, alphabet: bytes = BITCOIN_ALPHABET
) -> bytes:
    """
    Encode an integer using Base58
    """
    if not i and default_one:
        return alphabet[0:1]
    string = b""
    while i:
        i, idx = divmod(i, 58)
        string = alphabet[idx : idx + 1] + string
    return string


def b58encode(v: Union[str, bytes], alphabet: bytes = BITCOIN_ALPHABET) -> bytes:
    """
    Encode a string using Base58
    """
    v = scrub_input(v)

    nPad = len(v)
    v = v.lstrip(b"\0")
    nPad -= len(v)

    p, acc = 1, 0
    for c in reversed(v):
        acc += p * c
        p = p << 8
    result = b58encode_int(acc, default_one=False, alphabet=alphabet)
    return alphabet[0:1] * nPad + result


def b58decode_int(v: Union[str, bytes], alphabet: bytes = BITCOIN_ALPHABET) -> int:
    """
    Decode a Base58 encoded string as an integer
    """
    v = v.rstrip()
    v = scrub_input(v)

    decimal = 0
    for char in v:
        decimal = decimal * 58 + alphabet.index(char)
    return decimal


def b58decode(v: Union[str, bytes], alphabet: bytes = BITCOIN_ALPHABET) -> bytes:
    """
    Decode a Base58 encoded string
    """
    v = v.rstrip()
    v = scrub_input(v)

    origlen = len(v)
    v = v.lstrip(alphabet[0:1])
    newlen = len(v)

    acc = b58decode_int(v, alphabet=alphabet)

    result = []
    while acc > 0:
        acc, mod = divmod(acc, 256)
        result.append(mod)
    return b"\0" * (origlen - newlen) + bytes(reversed(result))

save this file and this directory create file btc with any name.py .( my file name has " btcGeneratorWallet.py " ) and first import this package for project in first file :

import argparse
import hashlib
import os
from binascii import hexlify, unhexlify
from struct import Struct
from utils import g, b58encode, b58decode
import blockcypher
from moneywagon import AddressBalance
import requests
from urllib.request import urlopen
from urllib.request import Request
import satoshi
import re

after import package can insert all code your file.py :


PACKER = Struct(">QQQQ")


def count_leading_zeroes(s):
    count = 0
    for c in s:
        if c == "\0":
            count += 1
        else:
            break
    return count


def base58_check_encode(prefix, payload, compressed=False):
    # Add version byte in front of RIPEMD-160 hash (0x00 for Main Network)
    s = prefix + payload
    if compressed:
        s = prefix + payload + b"\x01"
    # Add the 4 checksum bytes at the end of extended RIPEMD-160 hash. This is the 25-byte binary Bitcoin Address.
    checksum = hashlib.sha256(hashlib.sha256(s).digest()).digest()[0:4]
    result = s + checksum
    return "1" * count_leading_zeroes(result) + b58encode(result).decode()


def pub_key_to_addr(s):
    ripemd160 = hashlib.new("ripemd160")
    hash_sha256 = hashlib.new("SHA256")
    # Perform SHA-256 hashing on the public key
    hash_sha256.update(bytes.fromhex(s))
    # Perform RIPEMD-160 hashing on the result of SHA-256
    ripemd160.update(hash_sha256.digest())
    return base58_check_encode(b"\0", ripemd160.digest())


def btcwb(number):
    number0 = number >> 192
    number1 = (number >> 128) & 0xFFFFFFFFFFFFFFFF
    number2 = (number >> 64) & 0xFFFFFFFFFFFFFFFF
    number3 = number & 0xFFFFFFFFFFFFFFFF

    private_key = hexlify(PACKER.pack(number0, number1, number2, number3)).decode(
        "utf-8"
    )

    ###############################################
    print("Converting from: " + str(int(private_key, 16)))
    ###############################################

    compressed_key = base58_check_encode(b"\x80", unhexlify(private_key), True)

    ###############################################
    print("Private key    : " + compressed_key)
    ###############################################

    # address
    x, y = str(g * int(private_key, 16)).split()
    len1 = len(x)
    len2 = len(y)
    if len1 != 64:
        z = 64 - len1
        x = "0" * z + x
    if len2 != 64:
        z = 64 - len2
        y = "0" * z + y
    compressed_public_key_with_out_prefix = x + y
    pk_prefix = "02"
    if not int(compressed_public_key_with_out_prefix[64:], 16) % 2 == 0:
        pk_prefix = "03"
    compressed_public_key = pk_prefix + compressed_public_key_with_out_prefix[:64]

    ###############################################

    print("Public key     : " + compressed_public_key)
    print("Bitcoin address: " + pub_key_to_addr(compressed_public_key))
    with open("wallet.txt", "a") as f:
        f.write(
            "Converting from: "
            + str(int(private_key, 16))
            + "\nPrivate key: "
            + compressed_key
            + "\nPublic key: "
            + compressed_public_key
            + "\nBitcoin address: "
            + pub_key_to_addr(compressed_public_key)
            + "\n#####################################################################\n\n\n\n"
        )


def int_to_address(number):
    number0 = number >> 192
    number1 = (number >> 128) & 0xFFFFFFFFFFFFFFFF
    number2 = (number >> 64) & 0xFFFFFFFFFFFFFFFF
    number3 = number & 0xFFFFFFFFFFFFFFFF

    private_key = hexlify(PACKER.pack(number0, number1, number2, number3)).decode(
        "utf-8"
    )

    ###############################################
    print("Converting from: " + str(int(private_key, 16)))
    ###############################################

    compressed_key = base58_check_encode(b"\x80", unhexlify(private_key), True)

    ###############################################
    print("Private key    : " + compressed_key)
    ###############################################

    # address
    x, y = str(g * int(private_key, 16)).split()
    len1 = len(x)
    len2 = len(y)
    if len1 != 64:
        z = 64 - len1
        x = "0" * z + x
    if len2 != 64:
        z = 64 - len2
        y = "0" * z + y
    compressed_public_key_with_out_prefix = x + y
    pk_prefix = "02"
    if not int(compressed_public_key_with_out_prefix[64:], 16) % 2 == 0:
        pk_prefix = "03"
    compressed_public_key = pk_prefix + compressed_public_key_with_out_prefix[:64]

    ###############################################

    print("Public key     : " + compressed_public_key)
    ###############################################

    ###############################################
    print("Bitcoin address: " + pub_key_to_addr(compressed_public_key))
    try:
        total = blockcypher.get_total_balance(pub_key_to_addr(compressed_public_key))
    except:
        total = AddressBalance().action("btc", pub_key_to_addr(compressed_public_key))
    total_fiat = satoshi.to_fiat(int(total))
    # r = requests.get("https://blockchain.infor/rawaddr/{}".format(pub_key_to_addr(compressed_public_key)))
    tr = Request(
        "https://blockchain.info/q/getreceivedbyaddress/"
        + pub_key_to_addr(compressed_public_key)
    )
    total_received = str(urlopen(tr).read())
    trr = total_received[2:][:-1]
    total_fiat_received = satoshi.to_fiat(int(trr))

    ts = Request(
        "https://blockchain.info/q/getsentbyaddress/"
        + pub_key_to_addr(compressed_public_key)
    )
    total_sent = str(urlopen(ts).read())
    tsr = total_sent[2:][:-1]
    total_fiat_sent = satoshi.to_fiat(int(tsr))
    # print('$'+str(s))
    print("Total Sent     : " + str(tsr) + " || $" + str(total_fiat_sent))
    print("Total Received : " + str(trr) + " || $" + str(total_fiat_received))
    print("Final Balance  : " + str(total) + " || $" + str(total_fiat) + "\n")
    # stotal = blockcypher.from_satoshis(total, 'btc')
    with open("walletb.txt", "a") as f:
        f.write(
            "Converting from: "
            + str(int(private_key, 16))
            + "\nPrivate key: "
            + compressed_key
            + "\nPublic key: "
            + compressed_public_key
            + "\nBitcoin address: "
            + pub_key_to_addr(compressed_public_key)
            + "\nFianl Balance: "
            + str(total)
            + "\nTotal Received : "
            + str(trr)
            + " || $"
            + str(total_fiat_received)
            + "\nTotal Sent     : "
            + str(tsr)
            + " || $"
            + str(total_fiat_sent)
            + "\n#####################################################################\n\n\n\n"
        )
    if 0 < total:
        print(pub_key_to_addr(compressed_public_key) + " : " + total)
        with open("wallet_with_money.txt", "a") as m:
            m.write(
                "Converting from: "
                + str(int(private_key, 16))
                + "\nPrivate key: "
                + compressed_key
                + "\nPublic key: "
                + compressed_public_key
                + "\nBitcoin address: "
                + pub_key_to_addr(compressed_public_key)
                + "\nBitcoin Balance: "
                + str(total)
                + "\n#####################################################################\n\n\n\n"
            )
    else:
        pass
    ###############################################


def wif_to_key(wif):
    slicer = 4
    if wif[0] in ["K", "L"]:
        slicer = 5
    return hexlify(b58decode(wif)[1:-slicer]).decode("utf-8")


def main():
    try:
        os.system(r"cls")
    except:
        os.system(r"clear")
    print(
        """
 ____ _____ ____  __        __    _ _      _      ____                           _             
| __ )_   _/ ___| \ \      / /_ _| | | ___| |_   / ___| ___ _ __   ___ _ __ __ _| |_ ___  _ __ 
|  _ \ | || |      \ \ /\ / / _` | | |/ _ \ __| | |  _ / _ \ '_ \ / _ \ '__/ _` | __/ _ \| '__|
| |_) || || |___    \ V  V / (_| | | |  __/ |_  | |_| |  __/ | | |  __/ | | (_| | || (_) | |   
|____/ |_| \____|    \_/\_/ \__,_|_|_|\___|\__|  \____|\___|_| |_|\___|_|  \__,_|\__\___/|_|  
    Author    : Mohammadreza (MMDRZA.COM)
    Github    : https://mmdrza.com                                                                                                                                                                                                    
[1] Generate a List of Wallets with a Range [with Balances]
[2] Generate a List of Wallets with a Range [without Balances]
[3] Guess a Number List to Generate a Wallet
'q' for quit
     """
    )

    x = input(">>> ")
    if x == "q":
        try:
            quit()
        except:
            exit()
    elif x == "1":
        r1 = int(input("Input Starting Range :> "))
        r2 = int(input("Input Ending Range   :> "))
        for x in range(r1, r2):
            int_to_address(x)
    elif x == "2":
        r1 = int(input("Input Starting Range :> "))
        r2 = int(input("Input Ending Range   :> "))
        for x in range(r1, r2):
            btcwb(x)
    elif x == "3":
        print("Enter your lucky number in the following format:")
        print("ex: 1 2 456 788 123 657 11 66 234 68 23\n")
        array = map(int, input("Enter Numbers by Keeping Space : ").split())
        for i in array:
            int_to_address(i)
            i += 1
    else:
        print("Command not Recognized")


main()

for running this file and received result use this common in your terminal ( or cmd ) :
python btcGeneratorWallet.py ( this my file ) python <filename>.py

easy finder bitcoin private key wallet ( generator and finder )
can visit this site: https://key.config.ws for bitcoin wallet generator and keyword automatic finder free online .

CREATE PRIVATE KEY AND ADDRESS TRON PYTHON

MMDRZA — Wed, 05 Jan 2022 00:24:18 +0000

make and create wallet address and private key in tron network (trx) with help python for batch maker code sample . In this tool, many other models and methods can be used and it can be used for other ways, which I will try in the future for you, dear friends, more and more professional tools in this field. But as far as I could, I sent this tutorial simple so that even beginners can understand it from the beginning tron (TRX). I promise you the future development of this tool.

from tronpy.keys import PrivateKey
import time

a=1
while True:
    Private = PrivateKey.random()
    Address  = Private.public_key.to_base58check_address()
    print((a),'\nP:',Private,'\nA:',Address)
# You can change it in seconds. The less it is
# the faster you want the result. The more CPU it uses.
    time.sleep(1)
# You can delete this value if you do not need to number
# and sort the output results
    a=a+1

needed install this package "tronpy" can you install this code :

pip3 install tronpy