def main():
badger = connect_badger("deploy-final.json")
deployer = badger.deployer
controller = badger.getController("native")
governance = badger.devMultisig
strategist = badger.deployer
keeper = badger.keeper
guardian = badger.guardian
for (key, strategyName, isUniswap) in [
("native.sushiWbtcIbBtc", "StrategySushiLpOptimizer", False),
# ("native.uniWbtcIbBtc", "StrategyUniGenericLp", True),
]:
if isUniswap:
params = sett_config.uni.uniGenericLp.params
swap = UniswapSystem()
else:
params = sett_config.sushi.sushiWbtcIbBtc.params
params.badgerTree = badger.badgerTree
swap = SushiswapSystem()
if swap.hasPair(registry.tokens.ibbtc, registry.tokens.wbtc):
params.want = swap.getPair(registry.tokens.ibbtc, registry.tokens.wbtc)
else:
params.want = swap.createPair(
registry.tokens.ibbtc, registry.tokens.wbtc, deployer,
)
# NB: Work w/ sushi team to setup sushi reward allocations.
vault = badger.deploy_sett(
key,
params.want,
controller,
governance=governance,
strategist=strategist,
keeper=keeper,
guardian=guardian,
)
time.sleep(sleep_between_tx)
strategy = badger.deploy_strategy(
key,
strategyName,
controller,
params,
governance=governance,
strategist=strategist,
keeper=keeper,
guardian=guardian,
)
time.sleep(sleep_between_tx)
badger.wire_up_sett(vault, strategy, controller)
# TODO: Unpause vault.
assert vault.paused()
def fetch_params(self):
params = sett_config.uni.uniDiggWbtc.params
uniswap = UniswapSystem()
# TODO: Pull digg token addr from registry once its deployed.
if uniswap.hasPair(self.digg.token, registry.tokens.wbtc):
params.want = uniswap.getPair(self.digg.token,
registry.tokens.wbtc)
else:
params.want = uniswap.createPair(
self.digg.token,
registry.tokens.wbtc,
self.deployer,
)
want = params.want
params.token = self.digg.token
self.badger.deploy_logic("DiggRewardsFaucet",
DiggRewardsFaucet,
test=True)
self.rewards = self.badger.deploy_digg_rewards_faucet(
self.key, self.digg.token)
params.geyser = self.rewards
return (params, want)
def rebase(badger: BadgerSystem, account):
digg = badger.digg
supplyBefore = digg.token.totalSupply()
print("spfBefore", digg.token._sharesPerFragment())
print("supplyBefore", digg.token.totalSupply())
print(digg.cpiMedianOracle.getData.call())
sushi = SushiswapSystem()
pair = sushi.getPair(digg.token, registry.tokens.wbtc)
uni = UniswapSystem()
uniPair = uni.getPair(digg.token, registry.tokens.wbtc)
last_rebase_time = digg.uFragmentsPolicy.lastRebaseTimestampSec()
min_rebase_time = digg.uFragmentsPolicy.minRebaseTimeIntervalSec()
in_rebase_window = digg.uFragmentsPolicy.inRebaseWindow()
now = chain.time()
time_since_last_rebase = now - last_rebase_time
min_time_passed = (last_rebase_time + min_rebase_time) < now
console.print({
"last_rebase_time": last_rebase_time,
"in_rebase_window": in_rebase_window,
"now": now,
"time_since_last_rebase": time_since_last_rebase,
"min_time_passed": min_time_passed,
})
# Rebase if sufficient time has passed since last rebase and we are in the window.
# Give adequate time between TX attempts
if time_since_last_rebase > hours(
2) and in_rebase_window and min_time_passed:
console.print(
"[bold yellow]===== 📈 Rebase! 📉=====[/bold yellow]")
print("pair before", pair.getReserves())
print("uniPair before", uniPair.getReserves())
tx_timer.start_timer(account, "Rebase")
tx = digg.orchestrator.rebase({"from": account})
tx_timer.end_timer()
if rpc.is_active():
chain.mine()
print(tx.call_trace())
print(tx.events)
supplyAfter = digg.token.totalSupply()
print("spfAfter", digg.token._sharesPerFragment())
print("supplyAfter", supplyAfter)
print("supplyChange", supplyAfter / supplyBefore)
print("supplyChangeOtherWay", supplyBefore / supplyAfter)
print("pair after", pair.getReserves())
print("uniPair after", uniPair.getReserves())
else:
console.print("[white]===== No Rebase =====[/white]")
def _distributeWant(self, users) -> None:
digg = self.manager.badger.digg
# Generate lp tokens for users.
for user in users:
uniswap = UniswapSystem()
uniswap.addMaxLiquidity(
digg.token, registry.tokens.wbtc, user,
)
def pre_deploy_setup(self):
"""
Deploy StakingRewards for Strategy
"""
uniswap = UniswapSystem()
want = uniswap.getPair(self.badger.token, registry.tokens.wbtc)
self.rewards = self.badger.deploy_sett_staking_rewards(
self.key, want, self.badger.token)
def fetch_params(self):
params = sett_config.uni.uniGenericLp.params
uniswap = UniswapSystem()
want = uniswap.getPair(*self.tokens)
params.want = want
return (params, want)
def fetch_params(self):
params = sett_config.native.uniBadgerWbtc.params
uniswap = UniswapSystem()
want = uniswap.getPair(self.badger.token, registry.tokens.wbtc)
params.want = want
params.geyser = self.rewards
return (params, want)
def post_vault_deploy_setup(self, deploy=True):
"""
Generate LP tokens and grant to deployer
"""
if not deploy:
return
uniswap = UniswapSystem()
# Generate lp tokens.
uniswap.addMaxLiquidity(
self.digg.token,
registry.tokens.wbtc,
self.deployer,
)
def _distributeWant(self, users) -> None:
# Turn off guestlist.
self.core.setGuestList(AddressZero, {"from": self.core.owner()})
# Generate lp tokens for users.
for user in users:
# Mint ibBTC using sett lp tokens.
self._mintIbBtc(user)
swap = UniswapSystem()
if not self.isUniswap:
swap = SushiswapSystem()
# Generate lp tokens.
swap.addMaxLiquidity(
registry.tokens.ibbtc, registry.tokens.wbtc, user,
)
def deploy_uni_digg_wbtc_lp_sett(badger, digg):
"""
If test mode, add initial liquidity and distribute to test user
"""
deployer = badger.deployer
key = "native.uniDiggWbtc"
params = sett_config.uni.uniDiggWbtc.params
uniswap = UniswapSystem()
params.want = uniswap.getPair(digg.token, registry.tokens.wbtc)
params.token = digg.token
rewards = badger.deploy_digg_rewards_faucet(key, digg.token)
params.geyser = rewards
time.sleep(sleep_between_tx)
deploy_sett_by_key(
badger,
key,
"StrategyDiggLpMetaFarm",
SettType.DEFAULT,
params,
deployer=deployer,
governance=badger.devMultisig,
strategist=badger.deployer,
keeper=badger.keeper,
guardian=badger.guardian,
)
# assert False
strategy = badger.getStrategy(key)
rewards.grantRole(PAUSER_ROLE, badger.keeper, {"from": deployer})
rewards.grantRole(UNPAUSER_ROLE, badger.devMultisig, {"from": deployer})
# Make strategy the recipient of the DIGG faucet
rewards.initializeRecipient(strategy, {"from": deployer})
def swap_transfer(recipient, params):
badger = connect_badger("deploy-final.json")
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
multi = GnosisSafe(badger.devMultisig)
one_wei = Wei("1")
end_token = interface.IERC20(params["path"][-1])
console.print("Executing Swap:", style="yellow")
console.print(params)
# === Approve Uniswap Router on Rewards Escrow if not approved ===
uniswap = UniswapSystem()
assert badger.rewardsEscrow.isApproved(badger.token)
assert badger.rewardsEscrow.isApproved(uniswap.router)
# === Approve UNI Router for Badger ===
# Note: The allowance must first be set to 0
id = multi.addTx(
MultisigTxMetadata(
description="Approve UNI Router to send BADGER",
operation="call",
callInfo={
'address': uniswap.router,
'amount': params["max_in"] // 2
},
),
params={
"to":
badger.rewardsEscrow.address,
"data":
badger.rewardsEscrow.call.encode_input(
badger.token,
0,
badger.token.approve.encode_input(uniswap.router, 0),
),
},
)
tx = multi.executeTx(id)
# Set proper allowance
id = multi.addTx(
MultisigTxMetadata(
description="Approve UNI Router to send BADGER",
operation="call",
callInfo={
'address': uniswap.router,
'amount': params["max_in"] // 2
},
),
params={
"to":
badger.rewardsEscrow.address,
"data":
badger.rewardsEscrow.call.encode_input(
badger.token,
0,
badger.token.approve.encode_input(uniswap.router,
params["max_in"]),
),
},
)
tx = multi.executeTx(id)
console.print({
"rewardsEscrowBalance":
val(badger.token.balanceOf(badger.rewardsEscrow)),
"rewardsEscrowRouterAllowance":
val(badger.token.allowance(badger.rewardsEscrow, uniswap.router)),
"max_in":
val(params["max_in"]),
})
assert badger.token.balanceOf(badger.rewardsEscrow) > params["max_in"]
assert (badger.token.allowance(badger.rewardsEscrow, uniswap.router) >=
params["max_in"])
# === Trade Badger for USDC through WBTC ===
before = end_token.balanceOf(badger.rewardsEscrow)
beforeBadger = badger.token.balanceOf(badger.rewardsEscrow)
console.print({"EAO": params["exact_amount_out"]})
expiration = chain.time() + 8000
id = multi.addTx(
MultisigTxMetadata(
description="Trade Badger for output token",
operation="call",
callInfo={},
),
params={
"to":
badger.rewardsEscrow.address,
"data":
badger.rewardsEscrow.call.encode_input(
uniswap.router,
0,
uniswap.router.swapTokensForExactTokens.encode_input(
params["exact_amount_out"],
MaxUint256,
params["path"],
badger.rewardsEscrow,
expiration,
),
),
},
)
tx = multi.executeTx(id)
print(tx.call_trace())
print(tx.events)
printUniTrade(
method="swapTokensForExactTokens",
params=(
params["exact_amount_out"],
params["max_in"],
params['path'],
badger.rewardsEscrow,
expiration,
),
)
console.log("=== Post Trade ===")
console.print({
'before_input_coin':
beforeBadger,
'after_input_coin':
badger.token.balanceOf(badger.rewardsEscrow),
'before_output_coin':
before,
'post_output_coin':
end_token.balanceOf(badger.rewardsEscrow),
'end_token':
end_token,
'chain_time_before':
chain.time()
})
assert end_token.balanceOf(
badger.rewardsEscrow) >= params["exact_amount_out"]
# === Approve Recipient if not approved ===
if not badger.rewardsEscrow.isApproved(recipient):
id = multi.addTx(
MultisigTxMetadata(
description="Approve the transfer recipient",
operation="approveRecipient",
callInfo={},
),
params={
"to":
badger.rewardsEscrow.address,
"data":
badger.rewardsEscrow.approveRecipient.encode_input(recipient),
},
)
multi.executeTx(id)
assert badger.rewardsEscrow.isApproved(recipient)
# === Test Payment to recipient ===
before = end_token.balanceOf(recipient)
id = multi.addTx(
MultisigTxMetadata(
description="Test payment to recipientt",
operation="transfer",
callInfo={
"to": recipient,
"amount": one_wei
},
),
params={
"to":
badger.rewardsEscrow.address,
"data":
badger.rewardsEscrow.transfer.encode_input(end_token, recipient,
one_wei),
},
)
multi.executeTx(id)
after = end_token.balanceOf(recipient)
assert after == before + one_wei
# === Full Payment to recipient ===
rest = params["exact_amount_out"] - 1
before = end_token.balanceOf(recipient)
id = multi.addTx(
MultisigTxMetadata(
description="$12k payment to auditor, in USDC",
operation="transfer",
callInfo={
"to": recipient,
"amount": rest
},
),
params={
"to":
badger.rewardsEscrow.address,
"data":
badger.rewardsEscrow.transfer.encode_input(end_token, recipient,
rest),
},
)
multi.executeTx(id)
after = end_token.balanceOf(recipient)
assert after == before + rest
print(before, after, before + params["exact_amount_out"])
console.print("\n[green] ✅ Actions Complete [/green]")
def swap_transfer(recipient, params):
badger = connect_badger("deploy-final.json")
badger.paymentsMultisig = connect_gnosis_safe(
"0xD4868d98849a58F743787c77738D808376210292"
)
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
multi = GnosisSafe(badger.paymentsMultisig)
one_wei = Wei("1")
end_token = interface.IERC20(params["path"][-1])
console.print("Executing Swap:", style="yellow")
console.print(params)
# === Approve Uniswap Router on Rewards Escrow if not approved ===
uniswap = UniswapSystem()
# === Approve UNI Router for Badger ===
# Note: The allowance must first be set to 0
id = multi.addTx(
MultisigTxMetadata(
description="Approve UNI Router to send BADGER",
operation="call",
),
params={
"to": badger.token.address,
"data": badger.token.approve.encode_input(uniswap.router, 0),
},
)
tx = multi.executeTx(id)
# Set proper allowance
id = multi.addTx(
MultisigTxMetadata(
description="Approve UNI Router to send BADGER",
operation="call",
),
params={
"to": badger.token.address,
"data": badger.token.approve.encode_input(
uniswap.router, int(params["max_in"] * 1.5)
),
},
)
tx = multi.executeTx(id)
console.print(
{
"rewardsEscrowBalance": val(
badger.token.balanceOf(badger.paymentsMultisig)
),
"rewardsEscrowRouterAllowance": val(
badger.token.allowance(badger.paymentsMultisig, uniswap.router)
),
"max_in": val(params["max_in"]),
}
)
assert badger.token.balanceOf(badger.paymentsMultisig) > params["max_in"]
assert (
badger.token.allowance(badger.paymentsMultisig, uniswap.router)
>= params["max_in"]
)
# === Trade Badger ===
before = end_token.balanceOf(badger.paymentsMultisig)
beforeBadger = badger.token.balanceOf(badger.paymentsMultisig)
console.print({"EAO": params["exact_amount_out"]})
expiration = chain.time() + 8000
id = multi.addTx(
MultisigTxMetadata(
description="Trade Badger for output token",
operation="call",
callInfo={},
),
params={
"to": uniswap.router.address,
"data": uniswap.router.swapTokensForExactTokens.encode_input(
params["exact_amount_out"],
int(params["max_in"] * 1.5),
params["path"],
badger.paymentsMultisig,
expiration,
),
},
)
tx = multi.executeTx(id)
print(tx.call_trace())
print(tx.events)
printUniTrade(
method="swapTokensForExactTokens",
params=(
params["exact_amount_out"],
int(params["max_in"] * 1.5),
params["path"],
badger.paymentsMultisig,
expiration,
),
)
console.log("=== Post Trade ===")
console.print(
{
"before_input_coin": val(beforeBadger),
"after_input_coin": val(badger.token.balanceOf(badger.paymentsMultisig)),
"change_input_coin": val(
beforeBadger - badger.token.balanceOf(badger.paymentsMultisig)
),
"before_output_coin": val(before, decimals=end_token.decimals()),
"post_output_coin": val(
end_token.balanceOf(badger.paymentsMultisig),
decimals=end_token.decimals(),
),
"end_token": end_token,
"chain_time_before": chain.time(),
}
)
assert end_token.balanceOf(badger.paymentsMultisig) >= params["exact_amount_out"]
console.print("\n[green] ✅ Actions Complete [/green]")
def connect_uniswap_system(self):
self.uniswap_system = UniswapSystem()
def connect_uniswap(self):
self.uniswap = UniswapSystem()
def main():
"""
Connect to badger system, and configure multisig for running transactions in local fork without access to accounts
"""
# Connect badger system from file
badger = connect_badger()
digg = badger.digg
# Sanity check file addresses
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
if rpc.is_active():
distribute_test_ether(badger.devMultisig, Wei("5 ether"))
# Multisig wrapper
# Get price data from sushiswap, uniswap, and coingecko
digg_usd_coingecko = 41531.72
btc_usd_coingecko = 32601.13
digg_per_btc = digg_usd_coingecko / btc_usd_coingecko
uniTWAP = get_average_daily_price("scripts/oracle/data/uni_digg_hour")
sushiTWAP = get_average_daily_price("scripts/oracle/data/sushi_digg_hour")
averageTWAP = Average([uniTWAP, sushiTWAP])
console.print({
"uniTWAP": uniTWAP,
"sushiTWAP": sushiTWAP,
"averageTWAP": averageTWAP
})
supplyBefore = digg.token.totalSupply()
print("spfBefore", digg.token._sharesPerFragment())
print("supplyBefore", digg.token.totalSupply())
marketValue = Wei(str(averageTWAP) + " ether")
print(marketValue)
print(int(marketValue * 10**18))
print("digg_per_btc", digg_per_btc, averageTWAP, marketValue)
if rpc.is_active():
distribute_test_ether(digg.centralizedOracle, Wei("5 ether"))
centralizedMulti = GnosisSafe(digg.centralizedOracle)
print(digg.marketMedianOracle.providerReports(digg.centralizedOracle, 0))
print(digg.marketMedianOracle.providerReports(digg.centralizedOracle, 1))
print(digg.cpiMedianOracle.providerReports(digg.constantOracle, 0))
print(digg.cpiMedianOracle.providerReports(digg.constantOracle, 1))
print(digg.cpiMedianOracle.getData.call())
sushi = SushiswapSystem()
pair = sushi.getPair(digg.token, registry.tokens.wbtc)
uni = UniswapSystem()
uniPair = uni.getPair(digg.token, registry.tokens.wbtc)
print("pair before", pair.getReserves())
print("uniPair before", uniPair.getReserves())
tx = centralizedMulti.execute(
MultisigTxMetadata(description="Set Market Data"),
{
"to": digg.marketMedianOracle.address,
"data":
digg.marketMedianOracle.pushReport.encode_input(marketValue),
},
)
chain.mine()
print(tx.call_trace())
print(tx.events)
chain.sleep(hours(0.4))
chain.mine()
in_rebase_window = digg.uFragmentsPolicy.inRebaseWindow()
while not in_rebase_window:
print("Not in rebase window...")
chain.sleep(hours(0.1))
chain.mine()
in_rebase_window = digg.uFragmentsPolicy.inRebaseWindow()
tx = digg.orchestrator.rebase({"from": accounts[0]})
chain.mine()
supplyAfter = digg.token.totalSupply()
print("spfAfter", digg.token._sharesPerFragment())
print("supplyAfter", supplyAfter)
print("supplyChange", supplyAfter / supplyBefore)
print("supplyChangeOtherWay", supplyBefore / supplyAfter)
print("pair after", pair.getReserves())
print("uniPair after", uniPair.getReserves())
from helpers.gas_utils import gas_strategies
from helpers.registry import registry
from helpers.sett.SnapshotManager import SnapshotManager
from helpers.snapshot import diff_numbers_by_key, snap_strategy_balance
from helpers.utils import shares_to_fragments, to_digg_shares, to_tabulate, tx_wait
from rich.console import Console
from scripts.keeper.rapid_harvest import rapid_harvest
from scripts.systems.badger_system import BadgerSystem, connect_badger
from scripts.systems.digg_system import connect_digg
from scripts.systems.sushiswap_system import SushiswapSystem
from scripts.systems.uniswap_system import UniswapSystem
from tabulate import tabulate
gas_strategies.set_default(gas_strategies.exponentialScalingFast)
uniswap = UniswapSystem()
sushiswap = SushiswapSystem()
console = Console()
wbtc = interface.IERC20(registry.tokens.wbtc)
def lp_for_strategy(badger: BadgerSystem, key):
"""
Add maximum liquidity for associated strategy LP position
"""
manager = badger.badgerRewardsManager
strategy = badger.getStrategy(key)
want = interface.IERC20(strategy.want())
def main():
"""
Connect to badger, distribute assets to specified test user, and keep ganache open.
Ganache will run with your default brownie settings for mainnet-fork
"""
# The address to test with
user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
badger = connect_badger("deploy-final.json",
load_deployer=True,
load_keeper=True,
load_guardian=True)
digg = connect_digg("deploy-final.json")
digg.token = digg.uFragments
badger.add_existing_digg(digg)
console.print(
"[blue]=== 🦡 Test ENV for account {} 🦡 ===[/blue]".format(user))
distribute_test_ether(user, Wei("10 ether"))
distribute_test_ether(badger.deployer, Wei("20 ether"))
distribute_from_whales(user)
wbtc = interface.IERC20(token_registry.wbtc)
assert wbtc.balanceOf(user) >= 200000000
init_prod_digg(badger, user)
accounts.at(digg.daoDiggTimelock, force=True)
digg.token.transfer(user, 20000000000, {"from": digg.daoDiggTimelock})
digg_liquidity_amount = 1000000000
wbtc_liquidity_amount = 100000000
assert digg.token.balanceOf(user) >= digg_liquidity_amount * 2
assert wbtc.balanceOf(user) >= wbtc_liquidity_amount * 2
uni = UniswapSystem()
wbtc.approve(uni.router, wbtc_liquidity_amount, {"from": user})
digg.token.approve(uni.router, digg_liquidity_amount, {"from": user})
uni.router.addLiquidity(
digg.token,
wbtc,
digg_liquidity_amount,
wbtc_liquidity_amount,
digg_liquidity_amount,
wbtc_liquidity_amount,
user,
chain.time() + 1000,
{"from": user},
)
sushi = SushiswapSystem()
wbtc.approve(sushi.router, wbtc_liquidity_amount, {"from": user})
digg.token.approve(sushi.router, digg_liquidity_amount, {"from": user})
sushi.router.addLiquidity(
digg.token,
wbtc,
digg_liquidity_amount,
wbtc_liquidity_amount,
digg_liquidity_amount,
wbtc_liquidity_amount,
user,
chain.time() + 1000,
{"from": user},
)
console.print("[green]=== ✅ Test ENV Setup Complete ✅ ===[/green]")
# Keep ganache open until closed
time.sleep(days(365))
def create_uniswap_pair(token0, token1, signer):
uniswap = UniswapSystem()
if not uniswap.hasPair(token0, token1):
uniswap.createPair(token0, token1, signer)
return uniswap.getPair(token0, token1)