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