def __init__(self):
if cache.get("session") == None:
cache["session"] = requests.Session()
if cache.get("web3") == None:
cache["web3"] == Web3(Web3.HTTPProvider(DIGG_IT_INFURA_URL))
self.session = cache.get("session")
self.web3 = cache.get("web3")
self.eth = Etherscan(ETHERSCAN_API_KEY)
self.latest_block = self.get_latest_block()
self.rebases = self.get_rebases()
def main():
num, startblock, endblock, outpath = get_args()
ethscan = Etherscan(API_KEY)
web3 = Web3(Web3.HTTPProvider(infura_url))
features = ['address', 'num_txns', 'startblock', 'endblock']
master = dt.Frame(names=features)
skip = 0 # can't exceed 5000, max pages i guess
count = 1000 #max in a query is 1k
# while number of rows in dataset is < num
# go through a batch of transactions, get weekly txns per account, rbind to master, run unique
while master.nrows < num:
txns = uniswap_transactions(count, skip)
addresses = getAddresses(txns, web3)
if addresses is None:
skip = skip + count
if skip > 5000:
skip = 0
continue
skip = skip + count
if skip > 5000:
skip = 0
for addr in addresses:
#print("getting transactions by address")
try:
print(addr)
num_txns = len(
ethscan.get_normal_txs_by_address(
addr, startblock, endblock,
'desc')) # block difference approximately a week
except:
continue
#print("done, appending to master")
row = [[addr], [num_txns], [startblock],
[endblock]] # needs to be a list of lists for a row in dt
temp = dt.Frame(row, names=features)
master.rbind(temp)
#print("done")
print("Number of rows: {}".format(master.nrows))
master.to_csv(outpath, append=True)
def download_contract(address):
try:
eth = Etherscan(os.getenv('KEY'))
filename, source = _get_source_code(eth, address)
except AssertionError as e:
raise InvalidEtherscanKeyException(e)
_save_file(filename, source)
return filename[:-4]
def get_new_contracts(blocks):
with DbConnection() as db:
for index, block_no in blocks.items():
eth = Etherscan(os.getenv('KEY'))
logger.info(
"Searching for contracts starting with block %s, index %s",
block_no, index)
prev_call = time.time()
while db.get_amount(index) < int(
os.getenv('CONTRACTS_PER_TIMESTAMP')):
time.sleep(time.time() -
(prev_call - 0.2)) # Max 5 api calls per second
contracts, block_no = get_contracts_from_block_range(
eth, block_no)
prev_call = time.time()
logger.debug(
"For block_nos %s-%s (timestamp index %s), found %s contracts.",
block_no, block_no + 100, index, len(contracts))
db.add_contracts(contracts, block_no, index)
class Infura:
etherscan: Etherscan = False
def __init__(self):
self.etherscan = Etherscan()
print("Init Infura")
def get_transaction_information(self, tx_hash) -> Transaction:
# response = w3.eth.getTransaction(transaction_hash=tx_hash)
# transaction = Transaction(response)
# transaction = self.get_transaction_gas_used(transaction)
# return transaction
return self.etherscan.get_transaction_information(tx_hash=tx_hash)
def get_transaction_gas_used(self, transaction: Transaction):
response = w3.eth.waitForTransactionReceipt(transaction.tx_hash)
transaction.gas_used = response.gasUsed
return transaction
def retrieve_transaction(self, tx_hash) -> Transaction:
transaction = self.get_transaction_information(tx_hash)
transaction = self.get_transaction_gas_used(transaction)
return transaction
from api import API_KEY
from etherscan_py import etherscan_py
from etherscan import Etherscan
import matplotlib.pyplot as plt
eth = Etherscan(API_KEY)
client = etherscan_py.Client(API_KEY)
contract = str(input("Contract adress?"))
block = int(input("Block Number?"))
tx = client.get_all_transactions(from_address=contract,status=2,from_block=block)
nonce = []
address= []
for transaction in tx:
nonce.append(transaction.nonce)
address.append(transaction.from_address)
nonce , address = zip(*sorted(zip(nonce,address),reverse=True))
Eth_balance = []
for address in address:
Eth_balance.append(float(eth.get_eth_balance(address))/(10**18))
print(len(nonce),len(Eth_balance))
fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(nonce,"k+--",label="Number of transactions")
ax1.semilogy()
ax1.set_ylabel("Number of transactions")
ax2.plot(Eth_balance,"ro",label= "ETH balance")
ax2.semilogy()
staking_date = staking_eth['date'],
staking_amount = staking_eth['staked'],
txid = staking_eth['txid']
)
db.session.add(staking)
Config.set('staking_search_block', staking_eth['block_number'] + 1)
print ("Fetching deposits")
Deposit.query.delete()
for court in Court.query.all():
if court.address == "": continue
print("Fetching deposits for %s" % court.name)
for item in Etherscan.deposits(court.address):
deposit = Deposit(
address = item['from'],
cdate = datetime.utcfromtimestamp(int(item['timeStamp'])),
amount = int(item['value']) / 10**18,
txid = item['hash'],
token_contract = "XXX", # FIXME
court_id = court.id
)
db.session.add(deposit)
db.session.commit()
updated = strftime("%Y-%m-%d %H:%M:%S", gmtime())
Config.set('updated', updated)
api_key = os.environ.get('ETHERSCAN_API_KEY')
test_txs = [
'0x2f2484a81f79ad4bba3be406c2193ccfce0a071167a6853baf39d31ade693eee',
'0xb1d4da322012feebc45012b94182a8c1d294e1e123c261ef02349aa586031a9c',
'0x62d1dece34e9d06a86e61542e76983e12f8f7c38f54dfe2aa44725772822aab7',
'0x9ff1185d01f96e101baddce30f1e8cba16a03b95340cc80d5f688063fd0fe67d',
'0x8d720401121afe4524bb7f6a9842af5cb347e19da9784bbc9419ec53eb563b29',
'0xcd4973f26a83da507c73846e65c97aea507e2aaa0634c612fe309ed48bc2bfcf',
'0xfd7165bfd6bbcfa30f1b75d9ea0d67e88b760bedcc39f6de487c9394ab69b56a'
]
test_tx_hash = test_txs[5]
etherscan_api = Etherscan(api_key)
oneinch_exchange = OneInchExchange(address='')
def compose_swap_path_from_tx_hash(tx_hash, sender_address=None, debug=False):
# Get internal txs info
internal_txs = []
try:
internal_txs = etherscan_api.get_internal_txs_by_txhash(tx_hash)
except:
print("No internal transactions.")
tx_info = etherscan_api.get_proxy_transaction_by_hash(tx_hash)
sender_address = tx_info['from']
block_number = int(tx_info['blockNumber'][2:], 16)
def init_etherscan(self, apikey, net):
return Etherscan(apikey, net)
def miner(address):
r = requests.get(f"https://flexpool.io/{address}/exists")
if r.status_code == 404:
return redirect(url_for("index"))
else:
pass
# Address Hyperlink - Etherscan:
etherscan_link = f"https://etherscan.io/address/{address}"
# Address - Mobile Formatting:
address_mobile = f"{address[:8]}...{address[-6:]}"
# Miner Variable:
miner = flexpoolapi.miner(address)
# API Constants:
details = miner.details()
workers = miner.worker_count()
unpaid = miner.balance()
stats = miner.stats()
# Miner Details:
minimum_payout = (details.min_payout_threshold) / 10**18
pool_donation = (details.pool_donation) * 100
# Miner Worker Count:
workers_online = workers["online"]
workers_offline = workers["offline"]
# Miner Balance:
unpaid_balance = round((unpaid) / 10**18, 6)
# Percentage of Unpaid Balance Mined by Miner:
percentage = round(((unpaid_balance) / (minimum_payout)) * 100, 2)
# Miner Stats:
current_effective = round((stats.current_effective_hashrate) / 10**6, 2)
current_reported = round((stats.current_reported_hashrate) / 10**6, 2)
average_effective = round((stats.average_effective_hashrate) / 10**6, 2)
valid = (stats.valid_shares)
stale = (stats.stale_shares)
invalid = (stats.invalid_shares)
ETHERSCAN_KEY = environ.get("ETHERSCAN_KEY")
client = Etherscan(ETHERSCAN_KEY)
gas_prices = client.get_gas_oracle()
slow = gas_prices.get('SafeGasPrice')
normal = gas_prices.get('ProposeGasPrice')
fast = gas_prices.get('FastGasPrice')
return render_template("miner.html",
etherscan=etherscan_link,
address=address,
address_mobile=address_mobile,
minimum_payout=minimum_payout,
pool_donation=pool_donation,
workers_online=workers_online,
workers_offline=workers_offline,
unpaid_balance=unpaid_balance,
percentage_mined=percentage,
current_effective=current_effective,
current_reported=current_reported,
average_effective=average_effective,
valid_shares=valid,
stale_shares=stale,
invalid_shares=invalid,
slow=slow,
normal=normal,
fast=fast)
class DiggApi:
def __init__(self):
if cache.get("session") == None:
cache["session"] = requests.Session()
if cache.get("web3") == None:
cache["web3"] == Web3(Web3.HTTPProvider(DIGG_IT_INFURA_URL))
self.session = cache.get("session")
self.web3 = cache.get("web3")
self.eth = Etherscan(ETHERSCAN_API_KEY)
self.latest_block = self.get_latest_block()
self.rebases = self.get_rebases()
def get_latest_block(self) -> int:
return int(
self.eth.get_block_number_by_timestamp(
timestamp=round(time.time()), closest="before"
)
)
def get_rebases(self) -> list:
r = self.session.get("https://digg.finance/")
digg_supply_data = soup(r.content, "html.parser")
rebases = []
for row in digg_supply_data.find_all("table")[0].find_all("tr")[1:]:
rebase = {}
rebase["tx"] = row.contents[0].a["href"].split("/")[-1]
rebase["time"] = row.contents[1].text
rebase["supply"] = row.contents[2].text
rebase["change"] = row.contents[3].text
rebases.append(rebase)
return rebases
def get_rebases_web3(self) -> list:
# Use the supply delta contract because it has fewer transactions and is quicker to query
# to get the full list of rebases. Could use the digg contract but it requires getting
# more transactions because people trade with it.
rebase_contract_address = self.web3.toChecksumAddress(REBASE_DELTA_ADDRESS)
rebase_contract = self.web3.eth.contract(
address=rebase_contract_address, abi=REBASE_DELTA_ABI
)
# get list of transactions that emit a LogRebase event
rebase_txs = (
rebase_contract.events.LogRebase()
.createFilter(fromBlock=DIGG_START_BLOCK)
.get_all_entries()
)
rebases = []
for tx in rebase_txs:
rebase = {}
tx_hash = tx["transactionHash"].hex()
receipt = self.web3.eth.getTransactionReceipt(tx_hash)
tx_log = rebase_contract.events.LogRebase().processReceipt(receipt)
rebase["tx"] = tx_hash
rebase["block_number"] = tx_log[0]["blockNumber"]
rebase["supply"] = tx_log[0]["args"]["totalSupply"] / DIGG_DECIMALS
rebases.append(rebase)
return rebases
def get_digg_current_supply(self):
return Decimal(
self.session.get(
f"https://api.etherscan.io/api?module=stats&action=tokensupply&contractaddress={DIGG_ADDRESS}&tag=latest&apikey={ETHERSCAN_API_KEY}"
)
/ DIGG_DECIMALS
)
def get_historic_market_cap_since_block(self, block_number: int) -> list:
"""
Returns list of market cap every ETH_BLOCKS_PER_DAY / 2 (twice a day) since block_number.
return: list(list(timestamp, totx_digg_usdc_mcap, totx_digg_wbtc_mcap))
"""
historic_market_cap = []
logger.info(f"Getting historic market cap since: block {block_number}")
while block_number < self.latest_block:
entry = []
timestamp = self.eth.get_block_reward_by_block_number(
block_no=block_number
)["timeStamp"]
supply = self.get_digg_supply(timestamp, self.rebases)
wbtc_price = self.get_digg_wbtc_price_at_block(block_number)
# The digg wbtc pool didn't exist until a few thousand blocks after the
# digg contract was created. Only append entries for blocks with the pool.
if wbtc_price:
usdc_price = self.get_wbtc_usdc_price_at_block(block_number)
entry.append(timestamp)
entry.append(supply * usdc_price)
entry.append(supply * wbtc_price)
historic_market_cap.append(entry)
block_number += int(ETH_BLOCKS_PER_DAY / 2)
logger.info(
f"Grabbed historic market cap for {len(historic_market_cap)} entries"
)
logger.info(historic_market_cap)
return historic_market_cap
def get_digg_supply(self, tx_timestamp: str, rebases: list) -> Decimal:
"""
{
'tx': '0x8a20261d9443bf148b34b3767345f3992efd49bd96c9424918d6a17800a31c75',
'time': '2021-03-30 20:03:39',
'supply': '2638.800',
'change': '-1.90%'
}
"""
tx_datetime = datetime.utcfromtimestamp(int(tx_timestamp))
for rebase in rebases:
rebase_datetime = datetime.strptime(rebase["time"], "%Y-%m-%d %H:%M:%S")
if tx_datetime >= rebase_datetime:
return Decimal(rebase["supply"])
return Decimal(DIGG_INITIAL_SUPPLY)
def get_digg_wbtc_price_at_block(self, block_number: int) -> Decimal:
variables = {"pairId": WBTC_DIGG_PAIR_ID, "blockNumber": block_number}
request = self.session.post(
UNISWAP_SUBGRAPH, json={"query": UNISWAP_POOL_QUERY, "variables": variables}
)
logger.info(f"digg_wbtc_price: {request.json()}")
return (
None
if request.json()["data"]["pair"] == None
else Decimal(request.json()["data"]["pair"]["token0Price"])
)
def get_wbtc_usdc_price_at_block(self, block_number: int) -> Decimal:
variables = {"pairId": WBTC_USDC_PAIR_ID, "blockNumber": block_number}
request = self.session.post(
UNISWAP_SUBGRAPH, json={"query": UNISWAP_POOL_QUERY, "variables": variables}
)
return Decimal(request.json()["data"]["pair"]["token1Price"])
def get_address_erc20_token_txs(
self, start_block: int, user_address: str, token_address: str
) -> list:
latest_block = self.latest_block
all_txs = self.eth.get_erc20_token_transfer_events_by_address(
address=user_address,
startblock=start_block,
endblock=latest_block,
sort="asc",
)
token_txs = []
for tx in all_txs:
if tx["contractAddress"] == token_address:
token_txs.append(tx)
return token_txs
def get_digg_price_at_block(self, block_number: int) -> dict:
price = {}
# TODO: speed these calls up, right now taking too long. About 3 txs per second able to be processed
wbtc_in_usdc = self.get_wbtc_usdc_price_at_block(block_number)
price["digg_wbtc_price"] = self.get_digg_wbtc_price_at_block(block_number)
price["digg_usdc_price"] = wbtc_in_usdc * price["digg_wbtc_price"]
price["wbtc_usdc_price"] = wbtc_in_usdc
return price
def get_address_digg_balance(self, address: str) -> Decimal:
return Decimal(
self.get_address_token_balance(address, DIGG_ADDRESS) / DIGG_DECIMALS
)
def get_address_bdigg_balance(self, address: str) -> Decimal:
return Decimal(
self.get_address_token_balance(address, BDIGG_ADDRESS) / BDIGG_DECIMALS
)
def get_address_token_balance(self, wallet_address: str, token_address: str) -> int:
return self.eth.get_acc_balance_by_token_and_contract_address(
address=wallet_address, contract_address=token_address
)
parser.add_argument('--tsv',
action='store_true',
help='Output to TSV instead of JSON')
parser.add_argument('--verbose', action='store_true', help='Verbose mode.')
args = parser.parse_args()
start_date = None
end_date = None
if args.startdate != '':
start_date = datetime.date.fromisoformat(args.startdate)
if args.enddate != '':
end_date = datetime.date.fromisoformat(args.enddate)
api_key = load_etherscan_api_key()
contracts = load_contracts(args.contracts)
etherscan = Etherscan(api_key, read_only=not args.noupdate)
ethereum_footprint = EthereumFootprint()
summary = defaultdict(lambda: defaultdict(int))
output_json = {}
output_json['data'] = []
for name_kind, address in contracts.items():
if args.verbose:
print(name_kind)
transactions = list(
etherscan.load_transactions(address,
update=args.noupdate,
args = parser.parse_args()
start_date = None
end_date = None
if args.startdate != '':
start_date = datetime.date.fromisoformat(args.startdate)
if args.enddate != '':
end_date = datetime.date.fromisoformat(args.enddate)
with open('env.json') as f:
apikey = json.load(f)['etherscan-api-key']
with open('data/contracts.json') as f:
contracts = json.load(f)
etherscan = Etherscan(apikey)
ethereum_footprint = EthereumFootprint()
summary = defaultdict(lambda: defaultdict(int))
if not args.summary:
print(f'Name\tKind\tAddress\tGas\tTransactions\tkgCO2')
for name_kind, address in contracts.items():
if name_kind == 'Nifty Gateway/multiple':
if args.ng:
transactions = etherscan.load_transactions_multiple(
list_nifty_gateway(args.verbose),
update=args.noupdate,
verbose=args.verbose)
else:
continue
else:
import json
from collections import defaultdict
from etherscan import Etherscan
with open('data/contracts.json') as f:
contracts = json.load(f)
grouped = defaultdict(set)
for name_kind, address in contracts.items():
name, kind = name_kind.split('/')
grouped[name].update([(kind, address)])
etherscan = Etherscan()
for name, kinds_addresses in sorted(grouped.items()):
print(f'### {name}\n')
for kind, address in sorted(kinds_addresses):
dates = [tx.get_datetime() for tx in etherscan.load_transactions(address)]
min_date = min(dates).date()
max_date = max(dates).date()
print(f'* [{kind}](https://etherscan.io/address/{address}) {min_date} to {max_date}')
print()
# etherscan.io API
from etherscan import Etherscan
from etherscan_credentials import etherscanApikey
# etherscan.io personal API key
auth = Etherscan(etherscanApikey)
# call etherscan.io gas oracle
gasOni = auth.get_gas_oracle
print(f'Current Gas Prices', {gasOni})
print()
# Wallet Address variable
erc20Wallet = "0xddbd2b932c763ba5b1b7ae3b362eac3e8d40121a"
# get balance for wallet address
walletBalance = auth.get_eth_balance(address=erc20Wallet)
print(f'Eth Balance:', {walletBalance})
def __init__(self):
self.etherscan = Etherscan()
print("Init Infura")
import json
from etherscan import Etherscan
from utils import load_etherscan_api_key
from utils import valid_hash, prefix_contracts
api_key = load_etherscan_api_key()
etherscan = Etherscan(api_key, read_only=True)
deployer = '0x3b612a5b49e025a6e4ba4ee4fb1ef46d13588059'
transactions = etherscan.fetch_transactions_internal(deployer, verbose=True)
contracts = [e['contractAddress'] for e in transactions]
prefixed = prefix_contracts('Foundation', contracts, blocklist=[deployer])
with open('data/foundation-contracts.json', 'w') as f:
json.dump(prefixed, f, indent=2)
import json
import discord
import requests
from replit import db
from etherscan import Etherscan
from discord.ext import commands
# Discord Client (discord.py)
client = commands.Bot(command_prefix='!')
# Remove Default "!help" Command
client.remove_command("help")
# Get API Key for Etherscan Module
etherscan = Etherscan(os.getenv("ETHERSCAN"))
# API Endpoint for Flexpool
flexpool = "https://flexpool.io/api/v1"
@client.event
async def on_ready():
print("Logged in as {0.user}".format(client))
##### Custom !help Command: Help & Documentation #####
@client.group(invoke_without_command=True)
async def help(ctx):
# (Embed) - Help/Documentation:
help='Do not update cache.')
parser.add_argument('--nosave',
action='store_true',
help='Do not save output.')
parser.add_argument(
'--update_active',
type=int,
default=None,
help='Only update contracts that have had transactions in the last N days.'
)
parser.add_argument('--verbose', action='store_true', help='Verbose mode.')
args = parser.parse_args()
api_key = load_etherscan_api_key()
contracts = load_contracts(args.contracts)
etherscan = Etherscan(api_key)
gas_data = defaultdict(lambda: defaultdict(int))
fee_data = defaultdict(lambda: defaultdict(int))
tx_count_data = defaultdict(lambda: defaultdict(int))
global_gas_fees = 0
global_gas_used = 0
global_tx_count = 0
def print_stats(tx_count, gas_used, gas_fees):
print(f'\ttransactions {tx_count:,}')
print(f'\tgas_used {gas_used:,}')
print(f'\tgas_fees {gas_fees/1e18:,.2f} ETH ({gas_fees})')
