def setup():
"""
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("deploy-final.json")
digg = connect_digg("deploy-final.json")
# Sanity check file addresses
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
# Multisig wrapper
multi = GnosisSafe(badger.devMultisig, testMode=True)
manager = BadgerRewardsManager.at(
"0x5B60952481Eb42B66bdfFC3E049025AC5b91c127")
for key in strat_keys:
print(key)
strategy = badger.getStrategy(key)
multi.execute(
MultisigTxMetadata(
description="Transfer Keeper for {}".format(key)),
{
"to": strategy.address,
"data": strategy.setKeeper.encode_input(manager)
},
)
return manager
def main():
badger = connect_badger(badger_config.prod_json,
load_keeper=True,
load_guardian=True)
pendingContentHash = (
"0x346ec98585b52d981d43584477e1b831ce32165cb8e0a06d14d236241b36328e")
pendingFile = "rewards-1-" + str(pendingContentHash) + ".json"
with open(pendingFile) as f:
after_file = json.load(f)
pendingRewards = after_file
# pendingRewards = fetch_current_rewards_tree(badger)
currentRewards = fetch_current_rewards_tree(badger)
accounts[0].transfer(badger.keeper, Wei("5 ether"))
accounts[0].transfer(badger.guardian, Wei("5 ether"))
# Upgrade Rewards Tree
multi = GnosisSafe(badger.devMultisig)
newLogic = BadgerTree.at("0x0f81D3f48Fedb8E67a5b87A8a4De57766157f19B")
multi.execute(
MultisigTxMetadata(description="Upgrade Tree", ),
{
"to":
badger.opsProxyAdmin.address,
"data":
badger.opsProxyAdmin.upgrade.encode_input(badger.badgerTree,
newLogic),
},
)
assert (badger.badgerTree.hasRole(DEFAULT_ADMIN_ROLE,
badger.devMultisig.address) == True)
assert badger.badgerTree.getRoleMemberCount(DEFAULT_ADMIN_ROLE) == 1
assert badger.badgerTree.hasRole(ROOT_PROPOSER_ROLE,
badger.keeper.address) == True
assert badger.badgerTree.getRoleMemberCount(ROOT_PROPOSER_ROLE) == 1
# assert badger.badgerTree.hasRole(ROOT_VALIDATOR_ROLE, badger.guardian.address) == True
# assert badger.badgerTree.getRoleMemberCount(ROOT_VALIDATOR_ROLE) == 1
assert badger.badgerTree.hasRole(PAUSER_ROLE,
badger.guardian.address) == True
assert badger.badgerTree.getRoleMemberCount(PAUSER_ROLE) == 1
assert badger.badgerTree.hasRole(UNPAUSER_ROLE,
badger.devMultisig.address) == True
assert badger.badgerTree.getRoleMemberCount(UNPAUSER_ROLE) == 1
verify_rewards(
badger,
pendingRewards["startBlock"],
pendingRewards["endBlock"],
currentRewards,
pendingRewards,
)
def upgrade_sett(self, id, newLogic):
sett = self.getSett(id)
multi = GnosisSafe(self.devMultisig)
id = multi.addTx(
MultisigTxMetadata(description="Upgrade timelock"),
{
"to": self.proxyAdmin.address,
"data": self.proxyAdmin.upgrade.encode_input(sett, newLogic),
},
)
tx = multi.executeTx(id)
def governance_queue_transaction(self,
target,
signature,
data,
eta,
eth=0) -> str:
multi = GnosisSafe(self.devMultisig)
id = multi.addTx(
MultisigTxMetadata(description="Queue timelock transaction"),
{
"to":
self.governanceTimelock.address,
"data":
self.governanceTimelock.queueTransaction.encode_input(
target,
eth,
signature,
data,
eta,
),
},
)
multi.executeTx(id)
txHash = Web3.solidityKeccak(
[
"address",
"uint256",
"string",
"bytes",
"uint256",
],
[
target,
eth,
signature,
data,
eta,
],
).hex()
txFilename = "{}.json".format(txHash)
with open(os.path.join(TIMELOCK_DIR, txFilename), "w") as f:
# Dump tx data to timelock pending tx dir.
txData = {
"target": target,
"eth": eth,
"signature": signature,
"data": data.hex(),
"eta": eta,
}
f.write(json.dumps(txData, indent=4, sort_keys=True))
return txFilename
def multisig_action(badger: BadgerSystem):
multi = GnosisSafe(badger.opsMultisig)
key = "native.bDiggBtcb"
vault = badger.getSett(key)
strategy = badger.getStrategy(key)
multi.execute(
MultisigTxMetadata(description="Set PoolId"),
{"to": strategy.address, "data": strategy.setWantPid.encode_input(104)},
)
assert strategy.wantPid() == 104
def configure_router(self):
admin = self.admin
multi = GnosisSafe(admin)
for strategy in self.strategies.values():
multi.execute(
MultisigTxMetadata(description="Add Swap Strategy {}".format(
strategy.address)),
{
"to":
strategy.address,
"data":
self.router.addSwapStrategy.encode_input(strategy.address),
},
)
def main():
badger = connect_badger(badger_config.prod_json, load_keeper=True, load_guardian=True)
pendingContentHash = "0x07baafa95bf7c39ba948753dda64b2e82854b5a7597f6de9e15c23a96d0bfad3"
pendingFile = "rewards-1-" + str(pendingContentHash) + ".json"
with open(pendingFile) as f:
after_file = json.load(f)
pendingRewards = after_file
pendingRewards = fetch_current_rewards_tree(badger)
currentRewards = fetch_current_rewards_tree(badger)
accounts[0].transfer(badger.keeper, Wei("5 ether"))
accounts[0].transfer(badger.guardian, Wei("5 ether"))
# Upgrade Rewards Tree
multi = GnosisSafe(badger.devMultisig)
newLogic = BadgerTree.deploy({"from": badger.keeper})
multi.execute(
MultisigTxMetadata(
description="Upgrade Tree",
),
{
"to": badger.devProxyAdmin.address,
"data": badger.devProxyAdmin.upgrade.encode_input(badger.badgerTree, newLogic),
},
)
assert badger.badgerTree.hasRole(DEFAULT_ADMIN_ROLE, badger.devMultisig.address) == True
assert badger.badgerTree.getRoleMemberCount(DEFAULT_ADMIN_ROLE) == 1
assert badger.badgerTree.hasRole(ROOT_PROPOSER_ROLE, badger.keeper.address) == True
assert badger.badgerTree.getRoleMemberCount(ROOT_PROPOSER_ROLE) == 1
assert badger.badgerTree.hasRole(ROOT_VALIDATOR_ROLE, badger.guardian.address) == True
assert badger.badgerTree.getRoleMemberCount(ROOT_VALIDATOR_ROLE) == 1
assert badger.badgerTree.hasRole(PAUSER_ROLE, badger.guardian.address) == True
assert badger.badgerTree.getRoleMemberCount(PAUSER_ROLE) == 1
assert badger.badgerTree.hasRole(UNPAUSER_ROLE, badger.devMultisig.address) == True
assert badger.badgerTree.getRoleMemberCount(UNPAUSER_ROLE) == 1
# verify_rewards(badger, pendingRewards["startBlock"], pendingRewards["endBlock"], currentRewards, pendingRewards)
# push_rewards(badger, pendingContentHash)
if rpc.is_active():
test_claims(badger, pendingRewards["startBlock"], pendingRewards["endBlock"], currentRewards, pendingRewards)
def configure_strategies_grant_swapper_role(self, swapper):
admin = self.admin
multi = GnosisSafe(admin)
for strategy in self.strategies.values():
multi.execute(
MultisigTxMetadata(
description="Add Swapper Role to {}".format(swapper)),
{
"to":
swapper,
"data":
strategy.grantRole.encode_input(strategy.SWAPPER_ROLE(),
swapper),
},
)
def main():
"""
Transfer badger to recipient, ensuring they are approved as recipient first
Use test tx, full tx model
Can convert from dollar value
"""
badger = connect_badger("deploy-final.json")
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
multi = GnosisSafe(badger.devMultisig)
# Parameters
recipient = "0xd34C1d3853214bf049B760Ef48A580bfa7A9c8a1"
dollars = 50000
# amount = from_dollars(badger, badger.token.address, dollars)
amount = Wei("15907.8892303 ether")
params = {
"dollars": dollars,
"recipient": recipient,
"amount": amount,
"amount_scaled": val(amount),
"use_test_payment": False
}
console.print("===== Pre Transfer =====", style="bold cyan")
console.print(params)
transfer_badger(recipient, params)
console.print("===== Post Transfer =====", style="bold cyan")
def main():
badger = connect_badger("deploy-final.json")
multi = GnosisSafe(badger.opsMultisig)
account = accounts.load("badger_proxy_deployer")
print(account.address)
amount = Wei("10000 ether")
# print(badger.deployer)
# print(badger.token.balanceOf(badger.deployer), badger.token.balanceOf(badger.opsMultisig))
# multi.execute(MultisigTxMetadata(description="Transfer badger to EOA"), {
# "to": badger.token.address,
# "data": badger.token.transfer.encode_input(account, Wei("10000 ether"))
# })
# print(badger.token.balanceOf(account), badger.token.balanceOf(badger.opsMultisig))
# assert badger.token.balanceOf(account) >= amount
bBadger = badger.getSett("native.badger")
# badger.token.approve(bBadger, amount, {"from": account})
# bBadger.deposit(amount, {"from": account})
# tx_wait()
print(bBadger.balanceOf(account))
airdropProxy = AirdropDistributor.at(
"0xd17c7effa924b55951e0f6d555b3a3ea34451179")
bBadger.transfer(airdropProxy, bBadger.balanceOf(account),
{"from": account})
def main():
"""
Transfer badger to recipient, ensuring they are approved as recipient first
Use test tx, full tx model
Can convert from dollar value
"""
badger = connect_badger("deploy-final.json")
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
multi = GnosisSafe(badger.devMultisig)
# Parameters
recipient = "0xD73b03F1Ea390fEB20D879e4DFb83F1245C8D4be"
dollars = 45000
# amount = from_dollars(badger, badger.token.address, dollars)
amount = Wei("45000 ether")
params = {
"dollars": dollars,
"recipient": recipient,
"amount": amount,
"amount_scaled": val(amount),
"use_test_payment": True
}
console.print("===== Pre Transfer =====", style="bold cyan")
console.print(params)
transfer_badger(recipient, params)
console.print("===== Post Transfer =====", style="bold cyan")
def configure_bridge(badger: BadgerSystem, bridge: BridgeSystem):
"""
Configures bridge to use curve token wrapper.
"""
multi = GnosisSafe(badger.devMultisig)
id = multi.addTx(
MultisigTxMetadata(description="Set curve token wrapper on adapter",),
{
"to": bridge.adapter.address,
"data": bridge.adapter.setCurveTokenWrapper.encode_input(
bridge.curveTokenWrapper.address
),
},
)
multi.executeTx(id)
def whitelist_adapter_crv_sett(
badger: BadgerSystem,
bridge: BridgeSystem,
multi: GnosisSafe,
settID: str,
):
sett = badger.sett_system.vaults[settID]
id = multi.addTx(
MultisigTxMetadata(
description="Approve adapter access to sett {}".format(settID)
),
{
"to": sett.address,
"data": sett.approveContractAccess.encode_input(bridge.adapter.address),
},
)
multi.executeTx(id)
def grant_token_locking_permission(badger: BadgerSystem, locker):
multi = GnosisSafe(badger.devMultisig)
for key in keys:
geyser = badger.getGeyser(key)
print(key, geyser)
multi.execute(
MultisigTxMetadata(
description="Add Geyser permission for {} to {}".format(key, locker)
),
{
"to": geyser.address,
"data": geyser.grantRole.encode_input(TOKEN_LOCKER_ROLE, locker),
},
)
assert geyser.hasRole(TOKEN_LOCKER_ROLE, locker)
def main():
badger = connect_badger(badger_config.prod_json)
deployer = badger.deployer
multi = GnosisSafe(badger.devMultisig)
rebaseParams = {}
rebaseParams[
"minRebaseTimeIntervalSec"] = badger.digg.uFragmentsPolicy.minRebaseTimeIntervalSec(
)
rebaseParams[
"rebaseWindowOffsetSec"] = badger.digg.uFragmentsPolicy.rebaseWindowOffsetSec(
)
rebaseParams[
"rebaseWindowLengthSec"] = badger.digg.uFragmentsPolicy.rebaseWindowLengthSec(
)
console.print(rebaseParams)
newWindowLength = hours(6)
console.print(newWindowLength)
multi.execute(
MultisigTxMetadata(description="Set Rebase Params"),
{
"to":
badger.digg.uFragmentsPolicy.address,
"data":
badger.digg.uFragmentsPolicy.setRebaseTimingParameters.
encode_input(
rebaseParams["minRebaseTimeIntervalSec"],
rebaseParams["rebaseWindowOffsetSec"],
newWindowLength,
),
},
)
chain.mine()
tx = badger.digg.orchestrator.rebase({"from": badger.deployer})
print(tx.call_trace())
tx = badger.digg.orchestrator.rebase({"from": badger.deployer})
print(tx.call_trace())
def main():
badger = connect_badger()
digg = badger.digg
raw = 0.9566301
scaled = raw * 10**18
centralizedOracle = GnosisSafe(digg.centralizedOracle)
print("Raw Link")
print(raw)
print("Formatted for Median Oracle")
print(f"{scaled:.0f}")
tx = centralizedOracle.execute(
MultisigTxMetadata(description="Set Market Data"),
{
"to": digg.marketMedianOracle.address,
"data": digg.marketMedianOracle.pushReport.encode_input(scaled),
},
)
def test_main():
"""
What contracts are required?
Sett (Proxy)
GuestList (Proxy)
Strategy (Logic + Proxy)
What addresses do I need?
Fee splitter
Mushroom fee address
All that good stuff
"""
badger = connect_badger()
digg = badger.digg
dev = badger.deployer
distribute_from_whales(dev, assets=["digg"])
digg.token.transfer(badger.devMultisig, digg.token.balanceOf(dev), {"from": dev})
multi = GnosisSafe(badger.devMultisig)
safe = ApeSafe(badger.devMultisig.address)
ops = ApeSafe(badger.opsMultisig.address)
helper = ApeSafeHelper(badger, safe)
controller = safe.contract("0x9b4efA18c0c6b4822225b81D150f3518160f8609")
controller.setVault()
"""
address _token,
address _controller,
address _governance,
address _keeper,
address _guardian,
bool _overrideTokenName,
string memory _namePrefix,
string memory _symbolPrefix
"""
for i in range(0, len(assets)):
asset = interface.IERC20(assets[i])
vault = interface.ISett(vaults[i])
vault.initialize(
asset,
controller,
badger.devMultisig,
badger.keeper,
badger.guardian,
False,
"",
"",
)
controller.setVault(asset, vault)
def governance_execute_transaction(self, txFilename):
multi = GnosisSafe(self.devMultisig)
with open(os.path.join(TIMELOCK_DIR, txFilename), "r") as f:
txData = json.load(f)
id = multi.addTx(
MultisigTxMetadata(description="Execute timelock transaction"),
{
"to": self.governanceTimelock.address,
"data": self.governanceTimelock.executeTransaction.encode_input(
txData["target"],
txData["eth"],
txData["signature"],
txData["data"],
txData["eta"],
),
},
)
if multisig_success(multi.executeTx(id)):
os.remove(os.path.join(TIMELOCK_DIR, txFilename))
def main():
"""
- Swap tokens according to parameters. Swapped tokens are returned to the swapper
- Send test transaction to recipient. Amount is one Wei.
- Send full transaction to recipient. Amount is specified amount minus one Wei.
"""
badger = connect_badger("deploy-final.json")
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
multi = GnosisSafe(badger.devMultisig)
# Parameters
recipient = "0x08CeCe3D7e70f13afa91953Ba12b2315598ad7EA"
dollars = 65000
# Trade 'at max' Badger for exact amount of end coin
max_in = from_dollars(badger, badger.token.address, dollars * 1.2)
# exact_amount_out = from_dollars(badger, registry.tokens.wbtc, dollars)
exact_amount_out = dollars * 10**6
params = {
"dollars":
dollars,
"recipient":
recipient,
"token_in":
badger.token.address,
"token_out":
registry.tokens.usdt,
"swap_mode":
SwapMode.EXACT_AMOUNT_OUT,
"max_in":
max_in,
"max_in_scaled":
val(max_in),
"exact_amount_out":
exact_amount_out,
"exact_amount_out_scaled":
val(exact_amount_out),
"path": [
badger.token.address, registry.tokens.wbtc, registry.tokens.usdc,
registry.tokens.usdt
],
}
console.print("===== Pre Swap =====", style="bold cyan")
console.print(params)
swap_transfer(recipient, params)
console.print("===== Post Swap =====", style="bold cyan")
def deploy(self, sett_type=SettType.DEFAULT, deploy=True) -> BadgerSystem:
badger = connect_badger()
digg = badger.digg
dev = badger.deployer
timelock = badger.digg.daoDiggTimelock
multi = GnosisSafe(badger.devMultisig)
safe = ApeSafe(badger.devMultisig.address)
ops = ApeSafe(badger.opsMultisig.address)
bDigg = safe.contract_from_abi(
badger.getSett("native.digg").address, "Sett", Sett.abi
)
controller = ops.contract(badger.getController("experimental").address)
stabilizeVault = "0xE05D2A6b97dce9B8e59ad074c2E4b6D51a24aAe3"
diggTreasury = DiggTreasury.deploy({"from": dev})
strategy = StabilizeStrategyDiggV1.deploy({"from": dev})
strategy.initialize(
badger.devMultisig,
dev,
controller,
badger.keeper,
badger.guardian,
0,
[stabilizeVault, diggTreasury],
[250, 0, 50, 250],
{"from": dev},
)
diggTreasury.initialize(strategy, {"from": dev})
"""
address _governance,
address _strategist,
address _controller,
address _keeper,
address _guardian,
uint256 _lockedUntil,
address[2] memory _vaultConfig,
uint256[4] memory _feeConfig
"""
print("governance", controller.governance())
controller.approveStrategy(digg.token, strategy)
controller.setStrategy(digg.token, strategy)
self.badger = badger
return self.badger
def main():
'''
Queues crv sett upgrades to support depositFor() calls.
Also whitelists bridge adapter for crv setts.
'''
badger = connect_badger(badger_config.prod_json)
bridge = connect_bridge(badger_config.prod_json)
multi = GnosisSafe(badger.devMultisig)
for settID in CRV_SETTS_TO_UPGRADE:
txFilename = queue_upgrade_crv_sett(badger, settID)
console.print("[orange] queued up timelock tx {} [/orange]".format(txFilename))
whitelist_adapter_crv_sett(badger, bridge, multi, settID)
def test_signal_token_lock(badger: BadgerSystem, locker):
opsMulti = GnosisSafe(badger.opsMultisig)
for key in keys:
geyser = badger.getGeyser(key)
print(key, geyser)
opsMulti.execute(
MultisigTxMetadata(description="Test signal token lock"),
{
"to":
locker.address,
"data":
locker.signalTokenLocks.encode_input([
(geyser, badger.token, 1, 1, chain.time()),
(geyser, badger.digg.token, 2, 2, chain.time()),
]),
},
)
print(geyser.getUnlockSchedulesFor(badger.token))
print(geyser.getUnlockSchedulesFor(badger.digg.token))
def generate(self, badger, multi, key, distributions, start=0, duration=0, end=0):
dists = []
for asset, dist in distributions.items():
if dist == 0:
continue
console.print(
"===== Distributions for asset {} on {} =====".format(asset, key),
style="bold yellow",
)
token = asset_to_address(asset)
# == Distribute to Geyser ==
geyser = badger.getGeyser(key)
rewardsEscrow = badger.rewardsEscrow
multi = GnosisSafe(badger.devMultisig)
opsMulti = GnosisSafe(badger.opsMultisig)
print(key, geyser, rewardsEscrow)
if rewardsEscrow.isApproved(geyser) == False:
multi.execute(
MultisigTxMetadata(
description="Approve Recipient"
),
{
"to": rewardsEscrow.address,
"data": rewardsEscrow.approveRecipient.encode_input(geyser),
},
)
# Approve Geyser as recipient if required
if not rewardsEscrow.isApproved(geyser):
multi.execute(
MultisigTxMetadata(
description="Approve StakingRewards " + key,
operation="transfer",
),
{
"to": rewardsEscrow.address,
"data": rewardsEscrow.approveRecipient.encode_input(geyser),
},
)
numSchedules = geyser.unlockScheduleCount(token)
console.print(
"Geyser Distribution for {}: {}".format(key, val(dist)), style="yellow",
)
dists.append((geyser, asset_to_address(asset), dist, duration, start))
console.log(key, dists)
return dists
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("deploy-final.json")
# Sanity check file addresses
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
# Multisig wrapper
multi = GnosisSafe(badger.devMultisig, testMode=True)
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("deploy-final.json")
# Sanity check file addresses
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
# Multisig wrapper
multi = GnosisSafe(badger.devMultisig)
unlockLogic = UnlockScheduler.at(
"0xc63d8a22d18dd42a9de8343fd7c888bda3e7516d")
print(
unlockLogic.initialize.encode_input(badger.opsMultisig,
badger.opsMultisig,
badger.guardian,
badger.opsMultisig))
# dep2 = accounts.load("badger-deployer-2")
unlockProxy = UnlockScheduler.at(
"0x1AADc00011939499a4d263d657Dd74b0E1176cF9")
# unlockProxy = deploy_proxy(
# "UnlockScheduler",
# UnlockScheduler.abi,
# unlockLogic.address,
# badger.opsProxyAdmin.address,
# unlockLogic.initialize.encode_input(
# badger.opsMultisig, badger.opsMultisig, badger.guardian, badger.opsMultisig
# ),
# dep2,
# )
assert badger.opsProxyAdmin.getProxyImplementation(
unlockProxy) == unlockLogic
grant_token_locking_permission(badger, unlockProxy)
# Test run: Attempt to set unlock schedules
test_signal_token_lock(badger, unlockProxy)
def setup_badger(badger: BadgerSystem):
# Set paths
key = "native.bDiggBtcb"
sett = badger.getSett(key)
strategy = badger.getStrategy(key)
multi = GnosisSafe(badger.opsMultisig)
multi.execute(
MultisigTxMetadata(description="Set path"),
{
"to":
strategy.address,
"data":
strategy.setTokenSwapPath.encode_input(
registry.pancake.cake,
strategy.token0(),
[
registry.pancake.cake, registry.tokens.btcb,
strategy.token0()
],
),
},
)
multi.execute(
MultisigTxMetadata(description="Set path"),
{
"to":
strategy.address,
"data":
strategy.setTokenSwapPath.encode_input(
registry.pancake.cake,
strategy.token1(),
[registry.pancake.cake, registry.tokens.btcb],
),
},
)
def transfer(self, token, amount, recipient):
rewardsEscrow = self.badger.rewardsEscrow
multi = GnosisSafe(self.badger.devMultisig)
# Approve Geyser as recipient if required
if not rewardsEscrow.isApproved(recipient):
multi.execute(
MultisigTxMetadata(description="Approve Recipient " +
recipient.address),
{
"to": rewardsEscrow.address,
"data":
rewardsEscrow.approveRecipient.encode_input(recipient),
},
)
before = token.balanceOf(recipient)
# Top up Tree
# TODO: Make the amount based on what we'll require for the next week
id = multi.addTx(
MultisigTxMetadata(description="Send {} {} to {}".format(
token, amount, recipient)),
{
"to":
rewardsEscrow.address,
"data":
rewardsEscrow.transfer.encode_input(token, recipient, amount),
},
)
tx = multi.executeTx(id)
print(tx.call_trace())
after = token.balanceOf(recipient)
console.print({"before": before, "after": after})
assert after == before + amount
def main():
badger = connect_badger("deploy-final.json")
test_user = accounts.at(decouple.config("TEST_ACCOUNT"), force=True)
distribute_test_ether(test_user, Wei("20 ether"))
distribute_from_whales(test_user, assets=["bBadger", "badger", "usdc"])
rest = get_active_rewards_schedule(badger)
usdc = interface.IERC20(registry.tokens.usdc)
usdc_per_badger = 40.37 * 0.75
usdc_total = 13386240
multi = GnosisSafe(badger.devMultisig)
badger_total_scaled = usdc_total / usdc_per_badger
badger_total = Wei(str(badger_total_scaled) + " ether")
bBadger = badger.getSett("native.badger")
ppfs = bBadger.getPricePerFullShare()
bBadger_total = int(badger_total / ppfs * 10**18)
badger_total = Wei(str(badger_total_scaled) + " ether")
console.print({
"TRADE": "BASED",
"usdc_per_badger": usdc_per_badger,
"usdc_total": usdc_total,
"badger_total_scaled": badger_total_scaled,
"badger_total": badger_total,
"ppfs": ppfs,
"bBadger_total": str(bBadger_total),
})
params = {
"beneficiary": "0x3159b46a7829a0dbfa856888af768fe7146e7418",
"duration": days(182),
"usdcAmount": usdc_total * 10**6,
"bBadgerAmount": bBadger_total,
# "usdcAmount": 0,
# "bBadgerAmount": 0,
}
console.print(params)
# # Oxb1 Test
beneficiary = accounts.at(params["beneficiary"], force=True)
escrow = OtcEscrow.at("0x7163fB2fA38Ea3BBc1F8525F3d8D0417C0c9d903")
# bBadger.transfer(badger.devMultisig, Wei("100000 ether"), {"from": test_user})
pre = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
pre.print()
# assert usdc.balanceOf(params["beneficiary"]) >= params["usdcAmount"]
# multi.execute(MultisigTxMetadata(description="Transfer to 0xb1"), {
# "to": bBadger.address,
# "data": bBadger.transfer.encode_input(escrow, bBadger_total + Wei("1000 ether"))
# })
# assert usdc.allowance(beneficiary, escrow) >= params["usdcAmount"]
# usdc.approve(escrow, params["usdcAmount"], {"from": beneficiary})
# tx = escrow.swap({"from": beneficiary})
tx = multi.execute(MultisigTxMetadata(description="Swap"), {
"to": escrow.address,
"data": escrow.swap.encode_input()
},
print_output=False)
chain.mine()
print(tx.call_trace())
vesting = interface.ITokenTimelock(
tx.events["VestingDeployed"][0]["vesting"])
console.print({
"token": vesting.token(),
"beneficiary": vesting.beneficiary(),
"releaseTime": to_utc_date(vesting.releaseTime()),
})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
diff_token_balances(pre, post)
try:
vesting.release({"from": test_user})
except:
print("early vest failed!")
chain.sleep(days(182))
chain.mine()
# End
vesting.release({"from": test_user})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
diff_token_balances(pre, post)
return
escrow = OtcEscrow.deploy(
params["beneficiary"],
params["duration"],
params["usdcAmount"],
params["bBadgerAmount"],
{"from": badger.deployer},
)
beneficiary = accounts.at(params["beneficiary"], force=True)
usdc.transfer(beneficiary, params["usdcAmount"], {"from": test_user})
usdc.transfer(beneficiary, 1500000000000, {"from": test_user})
badger.token.transfer(badger.devMultisig, badger_total,
{"from": test_user})
multi.execute(
MultisigTxMetadata(description="Whitelist Multi"),
{
"to": bBadger.address,
"data": bBadger.approveContractAccess.encode_input(
badger.devMultisig),
},
)
assert badger.token.balanceOf(badger.devMultisig) > Wei("100 ether")
multi.execute(
MultisigTxMetadata(description="Approve bBadger Contract"),
{
"to": badger.token.address,
"data": badger.token.approve.encode_input(bBadger, badger_total),
},
)
multi.execute(
MultisigTxMetadata(description="Deposit"),
{
"to": bBadger.address,
"data": bBadger.deposit.encode_input(badger_total)
},
)
console.print(
"bBadger.balanceOf(badger.devMultisig)",
bBadger.balanceOf(badger.devMultisig), params["bBadgerAmount"],
params["bBadgerAmount"] - bBadger.balanceOf(badger.devMultisig))
assert bBadger.balanceOf(badger.devMultisig) >= params["bBadgerAmount"]
chain.mine()
chain.sleep(14)
chain.mine()
multi.execute(
MultisigTxMetadata(description="Transfer"),
{
"to": bBadger.address,
"data": bBadger.transfer.encode_input(escrow,
params["bBadgerAmount"]),
},
)
assert bBadger.balanceOf(escrow) == params["bBadgerAmount"]
multi.execute(
MultisigTxMetadata(description="Revoke"),
{
"to": escrow.address,
"data": escrow.revoke.encode_input()
},
)
assert bBadger.balanceOf(escrow) == 0
assert bBadger.balanceOf(badger.devMultisig) >= params["bBadgerAmount"]
print(bBadger.balanceOf(badger.devMultisig))
bBadger.transfer(escrow, params["bBadgerAmount"], {"from": test_user})
pre = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
console.print(pre)
assert usdc.balanceOf(beneficiary) >= params["usdcAmount"]
assert bBadger.balanceOf(escrow) == params["bBadgerAmount"]
usdc.approve(escrow, params["usdcAmount"], {"from": beneficiary})
tx = escrow.swap({"from": beneficiary})
post = get_token_balances(
[usdc, bBadger], [test_user, escrow, badger.devMultisig, beneficiary])
console.print(tx.events)
post.print()
diff_token_balances(pre, post)
vesting = interface.ITokenTimelock(
tx.events["VestingDeployed"][0]["vesting"])
console.print({
"token": vesting.token(),
"beneficiary": vesting.beneficiary(),
"releaseTime": to_utc_date(vesting.releaseTime()),
})
chain.sleep(days(365))
chain.mine()
vesting.release({"from": test_user})
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 testTransactions(self):
rewardsEscrow = self.badger.rewardsEscrow
multi = GnosisSafe(self.badger.devMultisig)
opsMulti = GnosisSafe(self.badger.opsMultisig)
# Setup
accounts[7].transfer(multi.get_first_owner(), Wei("2 ether"))
print(
"Supplied ETH",
accounts.at(multi.get_first_owner(), force=True).balance(),
)
badger = self.badger
tree = self.badger.badgerTree
before = badger.token.balanceOf(tree)
top_up = Wei("100000 ether")
top_up_digg = Wei("40 gwei")
harvest_badger = Wei("30000 ether")
harvest_digg = Wei("40 gwei")
# Top up Tree
# TODO: Make the amount based on what we'll require for the next week
id = multi.addTx(
MultisigTxMetadata(description="Top up badger tree with Badger"),
{
"to":
rewardsEscrow.address,
"data":
rewardsEscrow.transfer.encode_input(badger.token, tree,
top_up),
},
)
tx = multi.executeTx(id)
after = badger.token.balanceOf(tree)
assert after == before + top_up
before = badger.digg.token.balanceOf(tree)
tx = multi.execute(
MultisigTxMetadata(description="Top up badger tree with DIGG"),
{
"to":
rewardsEscrow.address,
"data":
rewardsEscrow.transfer.encode_input(badger.digg.token, tree,
top_up_digg),
},
)
print(tx.call_trace(), before, after)
after = badger.digg.token.balanceOf(tree)
assert after == before + top_up_digg
# multi.execute(
# MultisigTxMetadata(description="Top up rewards manager with Badger"),
# {
# "to": rewardsEscrow.address,
# "data": rewardsEscrow.transfer.encode_input(
# badger.token, badger.badgerRewardsManager, harvest_badger
# ),
# },
# )
multi.execute(
MultisigTxMetadata(description="Top up rewards manager with DIGG"),
{
"to":
rewardsEscrow.address,
"data":
rewardsEscrow.transfer.encode_input(
badger.digg.token, badger.badgerRewardsManager,
harvest_digg),
},
)
# grant_token_locking_permission(self.badger, self.badger.unlockScheduler)
geyserDists = []
for key, distribution in self.distributions.items():
if distribution.hasGeyserDistribution() == True:
print("has geyser distribution", key)
dist = GeyserDistributor()
dists = dist.generate(
badger,
multi,
key,
distributions=distribution.getGeyserDistributions(),
start=self.start,
duration=self.duration,
end=self.end,
)
geyserDists.extend(dists)
console.log("after " + key, geyserDists)
# Add unlock schedeules inbulk
console.log(geyserDists)
tx = opsMulti.execute(
MultisigTxMetadata(description="Signal unlock schedules"),
{
"to":
badger.unlockScheduler.address,
"data":
badger.unlockScheduler.signalTokenLocks.encode_input(
geyserDists),
},
)
print(tx.call_trace())
tokens = [self.badger.token.address, self.badger.digg.token.address]
for key in geyser_keys:
print(key)
geyser = self.badger.getGeyser(key)
for token in tokens:
print(token)
console.log(
"{} schedules for {}".format(token, key),
geyser.getUnlockSchedulesFor(token),
)
