def main(): user = accounts.load(input("brownie account: ")) print(f"loaded keeper account: {user}") registry = load_registry() vaults = load_vaults(registry) secho(f"loaded {len(vaults)} vaults", fg="yellow") keepers = [ keeper_registry[str(vault.strategy)] for vault in vaults if hasattr(vault.strategy, "strategist") and vault.strategy.strategist( ) == user and str(vault.strategy) in keeper_registry ] if not keepers: secho("nothing to keep, exiting", fg="yellow") return secho(f"keeping {len(keepers)} vaults", fg="green") for block in chain.new_blocks(): for keeper in keepers: secho(f">>> {block.number}", dim=True) gas_price = gas_price_geth() secho(f"gas price: {gas_price.to('gwei')} gwei") if keeper.harvest_trigger(gas_price): keeper.harvest(gas_price, user) time.sleep(600)
def main(): route = input(""" Choose an option: (1) Burn an asset on Matic (2) Withdraw an asset on Ethereum (3) Check burn tx checkpoint Choice: """) try: route = int(route) except ValueError: exit() if route == 1: asset = input("Input token to burn on matic: ") amount = int(input("Input amount of token to burn: ")) sender = (accounts.load(input("Account name: ")) if input("Do you want to load an account? [y/N] ") == "y" else MSG_SENDER) burn_asset_on_matic(asset, amount, sender) elif route == 2: burn_tx_hash = input("Input matic burn tx hash: ") sender = (accounts.load(input("Account name: ")) if input("Do you want to load an account? [y/N] ") == "y" else MSG_SENDER) withdraw_asset_on_ethereum(burn_tx_hash, sender) elif route == 3: burn_tx_hash = input("Enter burn tx hash: ") bar_fmt = "Blocks Mined: {n} blocks - Time Elapsed: {elapsed}" for block in tqdm(chain.new_blocks(1), bar_format=bar_fmt): if is_burn_checkpointed(burn_tx_hash, True): print( f"Tx {burn_tx_hash} has been checkpointed in block {block['number']}" ) break
def main(): prometheus.start(8800) yearn = Yearn() for block in chain.new_blocks(): data = yearn.describe() prometheus.export(data) logger.info('exported block=%d', block.number) time.sleep(sleep_interval)
def main(): yearn = Yearn() for block in chain.new_blocks(height_buffer=1): start_time = time.time() yearn.export(block.number, block.timestamp) duration = time.time() - start_time victoria.export_duration(duration, 1, "forwards", block.timestamp) time.sleep(sleep_interval)
def tvl(): yearn = Yearn() for block in chain.new_blocks(): data = yearn.total_value_at() total = sum(sum(vaults.values()) for vaults in data.values()) print(f"block={block.number} tvl={total}") logger.info('exported block=%d tvl=%.0f', block.number, total) time.sleep(sleep_interval)
def main(): treasury = Treasury(watch_events_forever=True) for block in chain.new_blocks(height_buffer=12): start_time = time.time() treasury.export(block.number, block.timestamp) duration = time.time() - start_time victoria.export_duration(duration, 1, "treasury_forwards", block.timestamp) time.sleep(sleep_interval)
def watch_events(self): start = time.time() self.log_filter = create_filter(self.addresses) for block in chain.new_blocks(height_buffer=12): logs = self.log_filter.get_new_entries() self.process_events(decode_logs(logs)) if not self._done.is_set(): self._done.set() logger.info("loaded v2 registry in %.3fs", time.time() - start) time.sleep(300)
def exporter_iearn(): earn_gauge = Gauge("iearn", "", ["vault", "param"]) start_http_server(8802) earns = iearn.load_iearn() for block in chain.new_blocks(): secho(f"{block.number}", fg="green") output = iearn.describe_iearn(earns) for name, data in output.items(): for param, value in data.items(): earn_gauge.labels(name, param).set(value) try_sleep()
def exporter_ironbank(): ironbank_gauge = Gauge("ironbank", "", ["vault", "param"]) start_http_server(8803) markets = ironbank.load_ironbank() for block in chain.new_blocks(): secho(f"{block.number}", fg="green") output = ironbank.describe_ironbank(markets) for name, data in output.items(): for param, value in data.items(): if value is None: continue ironbank_gauge.labels(name, param).set(value) try_sleep()
def watch_events(self): start = time.time() self.log_filter = create_filter(str(self.vault), topics=self._topics) for block in chain.new_blocks(height_buffer=12): logs = self.log_filter.get_new_entries() events = decode_logs(logs) self.process_events(events) if not self._done.is_set(): self._done.set() logger.info("loaded %d strategies %s in %.3fs", len(self._strategies), self.name, time.time() - start) time.sleep(300)
def exporter(): prom_gauge = Gauge('yearn', 'yearn stats', ['vault', 'param']) start_http_server(8800) registry = load_registry() vaults = load_vaults(registry) for block in chain.new_blocks(): secho(f'{block.number}', fg='green') for vault in vaults: secho(vault.name, fg='yellow') # secho(str(vault), dim=True) info = describe_vault(vault) for param, value in info.items(): # print(f'{param} = {value}') prom_gauge.labels(vault.name, param).set(value)
def exporter(): prom_gauge = Gauge("yearn", "yearn stats", ["vault", "param"]) timing = Gauge("yearn_timing", "", ["vault", "action"]) start_http_server(8800) registry = load_registry() # load vaults once, todo: update params with timing.labels("registry", "load").time(): vaults = load_vaults(registry) for block in chain.new_blocks(): secho(f"{block.number}", fg="green") for vault in vaults: with timing.labels(vault.name, "describe").time(): info = describe_vault(vault) for param, value in info.items(): # print(f'{param} = {value}') prom_gauge.labels(vault.name, param).set(value)
def exporter_v2(): vault_gauge = Gauge("yearn_vault", "", ["vault", "param"]) strat_gauge = Gauge("yearn_strategy", "", ["vault", "strategy", "param"]) timing = Gauge("yearn_timing", "", ["vault", "action"]) start_http_server(8801) for block in chain.new_blocks(): secho(f"{block.number}", fg="green") for vault in vaults_v2.VAULTS: secho(vault.name) with timing.labels(vault.name, "describe").time(): info = vault.describe() for param, value in info.items(): if param == "strategies": continue vault_gauge.labels(vault.name, param).set(value) for strat in info["strategies"]: for param, value in info["strategies"][strat].items(): strat_gauge.labels(vault.name, strat, param).set(value)
def watch_transfers(self): start = time.time() logger.info( 'pulling treasury transfer events, please wait patiently this takes a while...' ) for block in chain.new_blocks(height_buffer=12): for topics in self._topics: topic_filter = web3.eth.filter({ "fromBlock": self._start_block, "topics": topics }) logs = topic_filter.get_new_entries() self.process_transfers(logs) if not self._done.is_set(): self._done.set() logger.info("loaded treasury transfer events in %.3fs", time.time() - start) if not self._watch_events_forever: break time.sleep(30)
def main(): # set up prometheus log.info( f"Starting Prometheus scout-collector server at http://localhost:{PROMETHEUS_PORT}" ) block_gauge = Gauge( name="blocks", documentation="Info about blocks processed", ) coingecko_price_gauge = Gauge( name="coingecko_prices", documentation="Token price data from Coingecko", labelnames=["token", "countercurrency", "tokenAddress"], ) digg_gauge = Gauge( name="digg_price", documentation="Digg price data from oracle and AMMs", labelnames=["value"], ) lp_tokens_gauge = Gauge( name="lptokens", documentation="LP token data", labelnames=["token", "param", "tokenAddress"], ) crv_tokens_gauge = Gauge( name="crvtokens", documentation="CRV token data", labelnames=["token", "param", "tokenAddress"], ) sett_gauge = Gauge( name="sett", documentation="Badger Sett vaults data", labelnames=["sett", "param", "tokenAddress", "token"], ) wallets_gauge = Gauge( name="wallets", documentation="Watched wallet balances", labelnames=[ "walletName", "walletAddress", "token", "tokenAddress", "param" ], ) xchain_bridge_gauge = Gauge( name="xchainBridge", documentation="Info about tokens in custody", labelnames=["chain", "token", "bridge", "param"], ) rewards_gauge = Gauge( name="rewards", documentation="Badgertree reward holdings", labelnames=["token", "tokenAddress"], ) cycle_gauge = Gauge( name="badgertree", documentation="Badgertree reward timestamp", labelnames=["lastCycleUnixtime"], ) start_http_server(PROMETHEUS_PORT) # get all data num_treasury_tokens = len(treasury_tokens) str_treasury_tokens = "".join([ f"\n\t[bold]{token_name}: {token_address}" for token_name, token_address in treasury_tokens.items() ]) log.info( f"Loading ERC20 interfaces for treasury tokens ... {str_treasury_tokens}" ) token_interfaces = get_token_interfaces(treasury_tokens) badger = token_interfaces[treasury_tokens["BADGER"]] digg = token_interfaces[treasury_tokens["DIGG"]] wbtc = token_interfaces[treasury_tokens["WBTC"]] wallet_balances_by_token = get_wallet_balances_by_token( badger_wallets, treasury_tokens) lp_data = get_lp_data(lp_tokens) sett_data = get_sett_data(sett_vaults) digg_prices = get_digg_data(oracles["oracle"], oracles["oracle_provider"]) slpWbtcDigg = interface.Pair(lp_tokens["slpWbtcDigg"]) uniWbtcDigg = interface.Pair(lp_tokens["uniWbtcDigg"]) badgertree = interface.Badgertree(badger_wallets["badgertree"]) badgertree_cycles = get_badgertree_data(badgertree) # coingecko price query variables token_csv = ",".join(treasury_tokens.values()) countertoken_csv = "usd" # scan new blocks and update gauges for step, block in enumerate(chain.new_blocks(height_buffer=1)): timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") console.print() console.rule( title= f"[green]{timestamp} step number {step}, block number {block.number}" ) block_gauge.set(block.number) # process token prices token_prices = get_token_prices(treasury_tokens, token_csv, countertoken_csv) for token_name, token_address in treasury_tokens.items(): update_price_gauge( coingecko_price_gauge, token_prices, token_name, token_address, countertoken_csv, ) # process digg oracle prices update_digg_gauge(digg_gauge, digg_prices, slpWbtcDigg, uniWbtcDigg) # process lp data for lp_token in lp_data: update_lp_tokens_gauge(lp_tokens_gauge, lp_token, token_interfaces) # process curve pool data for pool_name, pool_address in crv_pools.items(): update_crv_tokens_gauge(crv_tokens_gauge, pool_name, pool_address) # process sett data for sett in sett_data: update_sett_gauge(sett_gauge, sett) # process wallet balances for *one* treasury token token_name, token_address = list( treasury_tokens.items())[step % num_treasury_tokens] update_wallets_gauge(wallets_gauge, wallet_balances_by_token, token_name, token_address) # process bridged tokens for custodian_name, custodian_address in custodians.items(): update_xchain_bridge_gauge(xchain_bridge_gauge, custodian_name, custodian_address, token_interfaces) # process rewards balances update_rewards_gauge(rewards_gauge, badgertree, badger, digg) # process badgertree cycles last_cycle_unixtime = badgertree_cycles.describe() update_cycle_gauge(cycle_gauge, last_cycle_unixtime)
def main(): for block in chain.new_blocks(height_buffer=1): process_and_cache_user_txs(postgres.last_recorded_block('user_txs'))
def main(): sett_gauge = Gauge("sett", "Data from Badger Vaults", ["sett", "param", "tokenAddress", "token"]) rewards_gauge = Gauge('rewards', '', ['token', 'tokenAddress']) digg_gauge = Gauge('digg_price', '', ['value']) cycle_guage = Gauge('badgertree', 'Badgretree rewards', ['lastCycleUnixtime']) coingecko_price_gauge = Gauge('coingecko_prices', 'Pricing data from Coingecko', ['token', 'countercurrency', 'tokenAddress']) lpTokens_gauge = Gauge('lptokens', "LP Token data", ['token', 'param', 'tokenAddress']) crvtoken_gauge = Gauge('crvtokens', "CRV token data", ['token', 'param', 'tokenAddress']) wallets_gauge = Gauge( 'wallets', 'Watched Wallet Balances', ['walletName', 'walletAddress', 'token', 'tokenAddress', 'param']) block_gauge = Gauge('blocks', 'Information about blocks processed') xchain_bridge_gauge = Gauge('xchainBridge', 'Information about tokens in custody', ['chain', 'token', 'bridge', 'param']) start_http_server(8801) lpTokens = get_lp_data() setts = get_sett_data() wallet_balances_by_token = {} for tokenName, tokenAddress in treasury_tokens.items(): wallet_balances_by_token[tokenAddress] = get_token_balance_data( badger_wallets, tokenAddress, tokenName) digg_prices = get_digg_data() badgertree_cycles = get_badgertree_data() countertoken_csv = "usd" token_csv = "" for key in treasury_tokens.keys(): token_csv += (treasury_tokens[key] + ",") token_csv.rstrip(",") # badger_price = token_prices[tokens["badger"]]["usd"] # digg_price = token_prices[tokens["digg"]]["usd"] # console.print(f"Badger: {badger_price}") # console.print(f"Digg: {digg_price}") step = 0 usd_prices_by_token_address = {} wallet_balance_by_token_address = {} for block in chain.new_blocks(height_buffer=1): step += 1 block_gauge.set(block.number) now = datetime.datetime.now() timestamp = (now.strftime("%Y-%m-%d %H:%M:%S")) console.rule( title= f'[green]{block.number} at {timestamp} step number {step} and block numbne {block.number}' ) block_gauge.set(block.number) console.print(f'Calculating reward holdings..') badger_rewards = badger.balanceOf(badgertree.address) / 1e18 digg_rewards = digg.balanceOf(badgertree.address) / 1e9 rewards_gauge.labels('BADGER', treasury_tokens['BADGER']).set(badger_rewards) rewards_gauge.labels('DIGG', treasury_tokens['DIGG']).set(digg_rewards) token_prices = get_json_request( url= f'https://api.coingecko.com/api/v3/simple/token_price/ethereum?contract_addresses={token_csv}&vs_currencies={countertoken_csv}', request_type='get') for token, address in treasury_tokens.items(): console.print(f'Processing Coingecko price for [bold]{token}...') for countertoken in countertoken_csv.split(","): # badger_price = token_prices[tokens["badger"]]["usd"] try: exists_test = token_prices[treasury_tokens[token].lower()] coingecko_price_gauge.labels( token, countertoken, address).set(token_prices[ treasury_tokens[token].lower()][countertoken]) usd_prices_by_token_address[address] = token_prices[ address.lower()]["usd"] if token == "WETH": coingecko_price_gauge.labels( "ETH", countertoken, address).set(token_prices[ treasury_tokens[token].lower()][countertoken]) except: console.print(f"can't get coingeck price for: {token}") for token in lpTokens: info = token.describe() console.print(f'Processing lpToken reserves [bold]{token.name}...') token0_address = Web3.toChecksumAddress(info["token0"]) token1_address = Web3.toChecksumAddress(info["token1"]) token0 = token_interfaces[token0_address] token1 = token_interfaces[token1_address] token0_reserve = info["token0_reserve"] token1_reserve = info["token1_reserve"] price = (token1_reserve / (10**token1.decimals()) / (info["totalSupply"] / (10**info["decimals"])) ) * usd_prices_by_token_address[token1_address] * 2 lpTokens_gauge.labels(token.name, f"{token0.symbol()}_supply", treasury_tokens[token.name]).set( token0_reserve / (10**token0.decimals())) lpTokens_gauge.labels(token.name, f"{token1.symbol()}_supply", treasury_tokens[token.name]).set( token1_reserve / (10**token1.decimals())) lpTokens_gauge.labels(token.name, "totalLpTokenSupply", treasury_tokens[token.name]).set( info["totalSupply"] / (10**info["decimals"])) try: usd_prices_by_token_address[lp_tokens[token.name]] = price lpTokens_gauge.labels(token.name, "usdPricePerShare", lp_tokens[token.name]).set(price) except: console.print( f"Failed to find USD price for lptoken {token.name}") for token in crvpools: console.print( f'Processing crv token data for [bold]{token}:{crvpools[token]}...' ) virtual_price = interface.CRVswap( crvpools[token]).get_virtual_price() / 1e18 usd_price = virtual_price * usd_prices_by_token_address[ treasury_tokens["WBTC"]] crvtoken_gauge.labels(token, "pricePerShare", treasury_tokens["WBTC"]).set(virtual_price) crvtoken_gauge.labels(token, "usdPricePerShare", treasury_tokens["WBTC"]).set(usd_price) usd_prices_by_token_address[treasury_tokens[token]] = usd_price # Processing Bridged tokens custodians = { "multiswap": Web3.toChecksumAddress( "0x533e3c0e6b48010873B947bddC4721b1bDFF9648") } for custodian, address in custodians.items(): console.print( f"Checking Balances on bridge {custodian} address {address}") for token in native_tokens: ti = token_interfaces[treasury_tokens[token]] xchain_bridge_gauge.labels( "BSC", token, custodian, "balance").set( ti.balanceOf(address) / (10**ti.decimals())) xchain_bridge_gauge.labels( "BSC", token, custodian, "usdBalance").set( ti.balanceOf(address) / (10**ti.decimals()) * usd_prices_by_token_address[treasury_tokens[token]]) # process wallets for one treasury token tokenAddress = treasury_tokens_address_list[step % number_treasury_tokens] name = treasury_tokens_name_list[step % number_treasury_tokens] console.print( f'Processing wallet balances for [bold]{name}:{tokenAddress}...') info = wallet_balances_by_token[tokenAddress] for metric in info.describe(): wallet_web3_addr = Web3.toChecksumAddress(metric["walletAddress"]) wallets_gauge.labels(metric["walletName"], metric["walletAddress"], metric["tokenName"], metric["tokenAddress"], "balance").set(metric["balance"]) wallets_gauge.labels( metric["walletName"], metric["walletAddress"], "ETH", "None", "balance").set( float( w3.fromWei(w3.eth.getBalance(wallet_web3_addr), 'ether'))) try: wallets_gauge.labels( metric["walletName"], metric["walletAddress"], "ETH", "None", "usdBalance").set( float( w3.fromWei(w3.eth.getBalance(wallet_web3_addr), 'ether')) * usd_prices_by_token_address[treasury_tokens["WETH"]]) wallets_gauge.labels( metric["walletName"], metric["walletAddress"], metric["tokenName"], metric["tokenAddress"], "usdBalance").set( metric["balance"] * usd_prices_by_token_address[tokenAddress]) except: console.print("error calculating USD token balance") for sett in setts: info = sett.describe() console.print(f'Processing Sett [bold]{sett.name}...') for param, value in info.items(): sett_gauge.labels(sett.name, param, sett_vaults[sett.name], sett.name[1:]).set(value) try: usd_prices_by_token_address[sett_vaults[sett.name]] = ( info["pricePerShare"] * usd_prices_by_token_address[treasury_tokens[re.sub( "harvest", "", sett.name[1:])]]) sett_gauge.labels( sett.name, "usdBalance", sett_vaults[sett.name], sett.name[1:]).set( usd_prices_by_token_address[sett_vaults[sett.name]] * info["balance"]) except: console.print(f"Could not set USD price for Sett {sett.name}") pass price = digg_prices.describe() last_cycle_unixtime = badgertree_cycles.describe() for param, value in last_cycle_unixtime.items(): console.print(f'Processing Badgertree [bold]{param}...') cycle_guage.labels(param).set(value) for param, value in price.items(): console.print(f'Processing Digg Oracle [bold]{param}...') digg_gauge.labels(param).set(value) digg_sushi_price = (slpDiggWbtc.getReserves()[0] / 1e8) / (slpDiggWbtc.getReserves()[1] / 1e9) digg_uni_price = (uniDiggWbtc.getReserves()[0] / 1e8) / (uniDiggWbtc.getReserves()[1] / 1e9) digg_gauge.labels('sushiswap').set(digg_sushi_price) digg_gauge.labels('uniswap').set(digg_uni_price)