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)
