def test_get_OCEAN_in_BPTs(alice_info):
state = MockSimState()
pool, DT = alice_info.pool, alice_info.DT
pool_agent = PoolAgent("pool_agent", pool)
state.agents["agent1"] = pool_agent
foo_agent = FooAgent("foo_agent")
OCEAN_address = globaltokens.OCEAN_address()
price = fromBase18(pool.getSpotPrice(OCEAN_address, DT.address))
pool_value_DT = price * fromBase18(pool.getBalance(DT.address))
pool_value_OCEAN = fromBase18(pool.getBalance(OCEAN_address))
pool_value = pool_value_DT + pool_value_OCEAN
# case: foo_agent no BPTs
value_held = KPIs.get_OCEAN_in_BPTs(state, foo_agent)
foo_agent_pool_shape = foo_agent._BPT / fromBase18(pool.totalSupply())
assert value_held == approx(foo_agent_pool_shape * pool_value)
# case: foo_agent has all BPTs
foo_agent._BPT = fromBase18(
pool.totalSupply()) # make pool think agent has 100% of BPTs
value_held = KPIs.get_OCEAN_in_BPTs(state, foo_agent)
assert value_held == 1.0 * pool_value
def _spotPrices(T1, T2, bal1: float, bal2: float, w1: float, w2: float): # pylint: disable=too-many-arguments
pool = _createPoolWith2Tokens(T1, T2, bal1, bal2, w1, w2)
a1, a2 = T1.address, T2.address
return (
fromBase18(pool.getSpotPrice(a1, a2)),
fromBase18(pool.getSpotPriceSansFee(a1, a2)),
)
def get_OCEAN_in_BPTs(state, agent):
"""Value of BPTs that this agent owns across all pools, denominated in OCEAN
Args:
state: SimState -- SimState, holds all pool agents (& their pools)
agent: AgentBase -- agent of interest
Returns:
value_held: float -- value of BPTs, denominated in OCEAN
"""
OCEAN_address = globaltokens.OCEAN_address()
value_held = 0
for pool_agent in state.agents.filterToPool().values():
pool = pool_agent._pool
DT = pool_agent._dt
price = fromBase18(pool.getSpotPrice(OCEAN_address, DT.address))
pool_value_DT = price * fromBase18(pool.getBalance(DT.address))
pool_value_OCEAN = fromBase18(pool.getBalance(OCEAN_address))
pool_value = pool_value_DT + pool_value_OCEAN
amt_pool_BPTs = fromBase18(pool.totalSupply())
agent_percent_pool = agent.BPT(pool) / amt_pool_BPTs
value_held += agent_percent_pool * pool_value
return value_held
def test_exitswapPoolAmountIn(T1, T2):
pool = _createPoolWith2Tokens(T1, T2, 90.0, 10.0, 9.0, 1.0)
BPT = pool
pool.finalize({"from": account0})
assert fromBase18(T1.balanceOf(address0)) == 910.0
tokenOut_address = T1.address
poolAmountIn = toBase18(10.0) # BPT spent
minAmountOut = toBase18(1.0) # min T1 wanted
pool.exitswapPoolAmountIn(tokenOut_address, poolAmountIn, minAmountOut,
{"from": account0})
assert fromBase18(T1.balanceOf(address0)) >= (910.0 + 1.0)
assert fromBase18(BPT.balanceOf(address0)) == (100.0 - 10.0)
def test_joinswapPoolAmountOut(T1, T2):
pool = _createPoolWith2Tokens(T1, T2, 90.0, 10.0, 9.0, 1.0)
BPT = pool
pool.finalize({"from": account0})
T1.approve(pool.address, toBase18(90.0), {"from": account0})
assert fromBase18(T1.balanceOf(address0)) == 910.0
tokenIn_address = T1.address
poolAmountOut = toBase18(10.0) # BPT wanted
maxAmountIn = toBase18(90.0) # max T1 to spend
pool.joinswapPoolAmountOut(tokenIn_address, poolAmountOut, maxAmountIn,
{"from": account0})
assert fromBase18(T1.balanceOf(address0)) >= (910.0 - 90.0)
assert fromBase18(BPT.balanceOf(address0)) == (100.0 + 10.0)
def _make_info(account):
assert account.address != GOD_ACCOUNT.address
OCEAN = globaltokens.OCEANtoken()
# reset OCEAN balances on-chain, to avoid relying on brownie chain reverts
# -assumes that DT and BPT in each test are new tokens each time, and
# therefore don't need re-setting
for a in accounts:
if a.address != GOD_ACCOUNT.address:
OCEAN.transfer(GOD_ACCOUNT, OCEAN.balanceOf(a), {"from": a})
class Info:
def __init__(self):
self.account = None
self.agent = None
self.DT = None
self.pool = None
info = Info()
info.account = account
class SimpleAgent(AgentBase.AgentBaseEvm):
def takeStep(self, state):
pass
info.agent = SimpleAgent("agent1", USD=0.0, OCEAN=0.0)
info.agent._wallet._account = account # force agent to use this account
info.agent._wallet.resetCachedInfo() # because account changed wallet
info.DT = _createDT(account)
info.agent._wallet.resetCachedInfo() # because DT was deposited to account
assert info.DT.balanceOf(account) == toBase18(_DT_INIT)
globaltokens.fundOCEANFromAbove(account.address, toBase18(_OCEAN_INIT))
info.agent._wallet.resetCachedInfo(
) # because OCEAN was deposited to account
info.pool = _createPool(info.DT, account) # create pool, stake DT & OCEAN
info.agent._wallet.resetCachedInfo() # because OCEAN & DT was staked
# postconditions
w = info.agent._wallet
OCEAN1 = w.OCEAN()
assert w._cached_OCEAN_base is not None
OCEAN2 = fromBase18(int(w._cached_OCEAN_base))
OCEAN3 = fromBase18(OCEAN.balanceOf(account))
assert OCEAN1 == OCEAN2 == OCEAN3, (OCEAN1, OCEAN2, OCEAN3)
return info
def transferOCEAN(self, dst_wallet, amt: float) -> None:
assert isinstance(dst_wallet, (AgentWalletEvm, BurnWallet))
dst_address = dst_wallet.address
amt_base = toBase18(amt)
assert amt_base >= 0
if amt_base == 0:
return
OCEAN_base = self._OCEAN_base()
if OCEAN_base == 0:
raise ValueError("no funds to transfer from")
tol = 1e-12
if (1.0 - tol) <= amt / fromBase18(OCEAN_base) <= (1.0 + tol):
amt_base = OCEAN_base
if amt_base > OCEAN_base:
raise ValueError(
"transfer amt ({fromBase18(amt_base)})"
" exceeds OCEAN holdings ({fromBase18(OCEAN_base)})"
)
globaltokens.OCEANtoken().transfer(
dst_address, amt_base, {"from": self._account}
)
dst_wallet._total_OCEAN_in += amt
self.resetCachedInfo()
dst_wallet.resetCachedInfo()
def test_stakeOCEAN(alice_info):
alice_info.agent._wallet.resetCachedInfo()
agent_wallet, pool = alice_info.agent._wallet, alice_info.pool
OCEAN = globaltokens.OCEANtoken()
BPT_before = agent_wallet.BPT(pool)
OCEAN1 = agent_wallet.OCEAN()
OCEAN2 = fromBase18(agent_wallet._cached_OCEAN_base)
OCEAN3 = fromBase18(OCEAN.balanceOf(agent_wallet.address))
assert OCEAN1 == OCEAN2 == OCEAN3
agent_wallet.stakeOCEAN(OCEAN_stake=20.0, pool=pool)
OCEAN_after, BPT_after = agent_wallet.OCEAN(), agent_wallet.BPT(pool)
assert OCEAN_after == (OCEAN1 - 20.0)
assert BPT_after > BPT_before
def test_exitswapExternAmountOut(T1, T2):
pool = _createPoolWith2Tokens(T1, T2, 90.0, 10.0, 9.0, 1.0)
BPT = pool
pool.finalize({"from": account0})
assert fromBase18(T1.balanceOf(address0)) == 910.0
tokenOut_address = T1.address
tokenAmountOut = toBase18(2.0) # T1 wanted
maxPoolAmountIn = toBase18(10.0) # max BPT spent
pool.exitswapExternAmountOut(
tokenOut_address,
tokenAmountOut, # T1 wanted
maxPoolAmountIn, # max BPT spent
{"from": account0},
)
assert fromBase18(T1.balanceOf(address0)) == (910.0 + 2.0)
assert fromBase18(BPT.balanceOf(address0)) >= (100.0 - 10.0)
def test_unbind(T1, T2):
pool = _createPoolWith2Tokens(T1, T2, 1.0, 1.0, 1.0, 1.0)
pool.unbind(T1.address, {"from": account0})
assert pool.getNumTokens() == 1
assert pool.getCurrentTokens() == [T2.address]
assert fromBase18(pool.getBalance(T2.address)) == 1.0
def test_calcSpotPrice():
pool = _deployBPool()
tokenBalanceIn = toBase18(10.0)
tokenWeightIn = toBase18(1.0)
tokenBalanceOut = toBase18(11.0)
tokenWeightOut = toBase18(1.0)
swapFee = 0
x = pool.calcSpotPrice(tokenBalanceIn, tokenWeightIn, tokenBalanceOut,
tokenWeightOut, swapFee)
assert round(fromBase18(x), 3) == 0.909
def test_calcPoolOutGivenSingleIn():
pool = _deployBPool()
tokenBalanceIn = toBase18(10.0)
tokenWeightIn = toBase18(1.0)
poolSupply = toBase18(120.0)
totalWeight = toBase18(2.0)
tokenAmountIn = toBase18(0.1)
swapFee = 0
x = pool.calcPoolOutGivenSingleIn(tokenBalanceIn, tokenWeightIn,
poolSupply, totalWeight, tokenAmountIn,
swapFee)
assert round(fromBase18(x), 3) == 0.599
def test_calcSingleOutGivenPoolIn():
pool = _deployBPool()
tokenBalanceOut = toBase18(10.0)
tokenWeightOut = toBase18(1.0)
poolSupply = toBase18(120.0)
totalWeight = toBase18(2.0)
poolAmountIn = toBase18(10.0)
swapFee = 0
x = pool.calcSingleOutGivenPoolIn(tokenBalanceOut, tokenWeightOut,
poolSupply, totalWeight, poolAmountIn,
swapFee)
assert round(fromBase18(x), 3) == 1.597
def test_joinSwapExternAmountIn(T1, T2):
pool = _createPoolWith2Tokens(T1, T2, 90.0, 10.0, 9.0, 1.0)
T1.approve(pool.address, toBase18(100.0), {"from": account0})
# pool's not public
with pytest.raises(Exception):
tokenIn_address = T1.address
maxAmountIn = toBase18(100.0)
tokenOut_address = T2.address
tokenAmountOut = toBase18(10.0)
maxPrice = HUGEINT
pool.swapExactAmountOut(
tokenIn_address,
maxAmountIn,
tokenOut_address,
tokenAmountOut,
maxPrice,
{"from": account0},
)
# pool's public
pool.setPublicSwap(True, {"from": account0})
tokenIn_address = T1.address
maxAmountIn = toBase18(100.0)
tokenOut_address = T2.address
tokenAmountOut = toBase18(1.0)
maxPrice = HUGEINT
pool.swapExactAmountOut(
tokenIn_address,
maxAmountIn,
tokenOut_address,
tokenAmountOut,
maxPrice,
{"from": account0},
)
assert 908.94 <= fromBase18(T1.balanceOf(address0)) <= 908.95
assert fromBase18(T2.balanceOf(address0)) == (1000.0 - 9.0)
def test_2tokens_basic(T1, T2):
pool = _deployBPool()
assert T1.address != T2.address
assert T1.address != pool.address
assert fromBase18(T1.balanceOf(address0)) >= 90.0
assert fromBase18(T2.balanceOf(address0)) >= 10.0
with pytest.raises(Exception): # can't bind until we approve
pool.bind(T1.address, toBase18(90.0), toBase18(9.0))
# Bind two tokens to the pool
T1.approve(pool.address, toBase18(90.0), {"from": account0})
T2.approve(pool.address, toBase18(10.0), {"from": account0})
assert fromBase18(T1.allowance(address0, pool.address)) == 90.0
assert fromBase18(T2.allowance(address0, pool.address)) == 10.0
assert not pool.isBound(T1.address) and not pool.isBound(T1.address)
pool.bind(T1.address, toBase18(90.0), toBase18(9.0), {"from": account0})
pool.bind(T2.address, toBase18(10.0), toBase18(1.0), {"from": account0})
assert pool.isBound(T1.address) and pool.isBound(T2.address)
assert pool.getNumTokens() == 2
assert pool.getCurrentTokens() == [T1.address, T2.address]
assert pool.getDenormalizedWeight(T1.address) == toBase18(9.0)
assert pool.getDenormalizedWeight(T2.address) == toBase18(1.0)
assert pool.getTotalDenormalizedWeight() == toBase18(9.0 + 1.0)
assert pool.getNormalizedWeight(T1.address) == toBase18(0.9)
assert pool.getNormalizedWeight(T2.address) == toBase18(0.1)
assert pool.getBalance(T1.address) == toBase18(90.0)
assert pool.getBalance(T2.address) == toBase18(10.0)
assert str(pool)
def test_get_OCEAN_in_DTs(alice_info):
state = MockSimState()
pool, DT = alice_info.pool, alice_info.DT
pool_agent = PoolAgent("pool_agent", pool)
state.agents["agent1"] = pool_agent
foo_agent = FooAgent("foo_agent")
OCEAN_address = globaltokens.OCEAN_address()
price = fromBase18(pool.getSpotPrice(OCEAN_address, DT.address))
amt_DT = foo_agent.DT("bar")
assert amt_DT == 3.0
value_held = KPIs.get_OCEAN_in_DTs(state, foo_agent)
assert value_held == amt_DT * price
def test_calcPoolInGivenSingleOut():
pool = _deployBPool()
tokenBalanceOut = toBase18(1000.0)
tokenWeightOut = toBase18(5.0)
poolSupply = toBase18(100.0)
totalWeight = toBase18(10.0)
tokenAmountOut = toBase18(0.1)
swapFee = 0
x = pool.calcPoolInGivenSingleOut(
tokenBalanceOut,
tokenWeightOut,
poolSupply,
totalWeight,
tokenAmountOut,
swapFee,
)
assert round(fromBase18(x), 3) == 0.005
def test_calcInGivenOut():
pool = _deployBPool()
tokenBalanceIn = toBase18(10.0)
tokenWeightIn = toBase18(1.0)
tokenBalanceOut = toBase18(10.1)
tokenWeightOut = toBase18(1.0)
tokenAmountOut = toBase18(1.0)
swapFee = 0
x = pool.calcInGivenOut(
tokenBalanceIn,
tokenWeightIn,
tokenBalanceOut,
tokenWeightOut,
tokenAmountOut,
swapFee,
)
assert round(fromBase18(x), 3) == 1.099
def get_OCEAN_in_DTs(state, agent) -> float:
"""Value of DT that this agent staked across all pools, denominated in OCEAN
Args:
state: SimState -- SimState, holds all pool agents (& their pools)
agent: AgentBase -- agent of interest
Returns:
value_held: float -- value staked, denominated in OCEAN
"""
OCEAN_address = globaltokens.OCEAN_address()
value_held = 0.0
for pool_agent in state.agents.filterToPoolV4().values():
pool = pool_agent._pool
DT = pool_agent._dt
swapFee = pool.getSwapFee()
price = fromBase18(pool.getSpotPrice(OCEAN_address, DT.address, swapFee))
amt_DT = agent.DT(DT)
value_held += amt_DT * price
return value_held
def transferDT(self, dst_wallet, DT, amt: float) -> None:
assert isinstance(dst_wallet, (AgentWalletEvm, BurnWallet))
dst_address = dst_wallet.address
amt_base = toBase18(amt)
assert amt_base >= 0
if amt_base == 0:
return
DT_base = self._DT_base(DT)
if DT_base == 0:
raise ValueError("no data tokens to transfer")
tol = 1e-12
if (1.0 - tol) <= amt / fromBase18(DT_base) <= (1.0 + tol):
amt_base = DT_base
if amt_base > DT_base:
raise ValueError(
f"transfer amt ({fromBase18(amt_base)})"
" exceeds DT holdings ({fromBase18(DT_base)})"
)
DT.transfer(dst_address, amt_base, {"from": self._account})
def test_public_pool(T1, T2):
pool = _createPoolWith2Tokens(T1, T2, 90.0, 10.0, 9.0, 1.0)
BPT = pool
# alice give Bob some tokens
T1.transfer(address1, toBase18(100.0), {"from": account0})
T2.transfer(address1, toBase18(100.0), {"from": account0})
# verify holdings
assert fromBase18(T1.balanceOf(address0)) == (1000.0 - 90.0 - 100.0)
assert fromBase18(T2.balanceOf(address0)) == (1000.0 - 10.0 - 100.0)
assert fromBase18(BPT.balanceOf(address0)) == 0
assert fromBase18(T1.balanceOf(address1)) == 100.0
assert fromBase18(T2.balanceOf(address1)) == 100.0
assert fromBase18(BPT.balanceOf(address1)) == 0
assert fromBase18(T1.balanceOf(pool.address)) == 90.0
assert fromBase18(T2.balanceOf(pool.address)) == 10.0
assert fromBase18(BPT.balanceOf(pool.address)) == 0
# finalize
pool.finalize({"from": account0})
# verify holdings
assert fromBase18(T1.balanceOf(address0)) == (1000.0 - 90.0 - 100.0)
assert fromBase18(T2.balanceOf(address0)) == (1000.0 - 10.0 - 100.0)
assert fromBase18(BPT.balanceOf(address0)) == 100.0 # new!
assert fromBase18(T1.balanceOf(pool.address)) == 90.0
assert fromBase18(T2.balanceOf(pool.address)) == 10.0
assert fromBase18(BPT.balanceOf(pool.address)) == 0
# bob join pool. Wants 10 BPT
T1.approve(pool.address, toBase18(100.0), {"from": account1})
T2.approve(pool.address, toBase18(100.0), {"from": account1})
poolAmountOut = toBase18(10.0) # 10 BPT
maxAmountsIn = [toBase18(100.0), toBase18(100.0)]
pool.joinPool(poolAmountOut, maxAmountsIn, {"from": account1})
# verify holdings
assert fromBase18(T1.balanceOf(address0)) == (1000.0 - 90.0 - 100.0)
assert fromBase18(T2.balanceOf(address0)) == (1000.0 - 10.0 - 100.0)
assert fromBase18(BPT.balanceOf(address0)) == 100.0
assert fromBase18(T1.balanceOf(address1)) == (100.0 - 9.0)
assert fromBase18(T2.balanceOf(address1)) == (100.0 - 1.0)
assert fromBase18(BPT.balanceOf(address1)) == 10.0
assert fromBase18(T1.balanceOf(pool.address)) == (90.0 + 9.0)
assert fromBase18(T2.balanceOf(pool.address)) == (10.0 + 1.0)
assert fromBase18(BPT.balanceOf(pool.address)) == 0
# bob sells 2 BPT
# -this is where BLabs fee kicks in. But the fee is currently set to 0.
poolAmountIn = toBase18(2.0)
minAmountsOut = [toBase18(0.0), toBase18(0.0)]
pool.exitPool(poolAmountIn, minAmountsOut, {"from": account1})
assert fromBase18(T1.balanceOf(address1)) == 92.8
assert fromBase18(T2.balanceOf(address1)) == 99.2
assert fromBase18(BPT.balanceOf(address1)) == 8.0
# bob buys 5 more BPT
poolAmountOut = toBase18(5.0)
maxAmountsIn = [toBase18(90.0), toBase18(90.0)]
pool.joinPool(poolAmountOut, maxAmountsIn, {"from": account1})
assert fromBase18(BPT.balanceOf(address1)) == 13.0
# bob fully exits
poolAmountIn = toBase18(13.0)
minAmountsOut = [toBase18(0.0), toBase18(0.0)]
pool.exitPool(poolAmountIn, minAmountsOut, {"from": account1})
assert fromBase18(BPT.balanceOf(address1)) == 0.0
def test_sideStaking_properties():
brownie.chain.reset()
OCEAN = OCEANtoken()
OCEAN_base_funding = 10000
do_extra_funding = False
OCEAN_extra_funding = 10000
OCEAN_init_liquidity = 2000 # initial liquidity in OCEAN on pool creation
DT_OCEAN_rate = 0.1
DT_cap = 10000
DT_vest_amt = 1000
DT_vest_num_blocks = 600
(DT, pool, ssbot) = _deployBPool(
OCEAN_base_funding,
do_extra_funding,
OCEAN_extra_funding,
OCEAN_init_liquidity,
DT_OCEAN_rate,
DT_cap,
DT_vest_amt,
DT_vest_num_blocks,
)
# basic tests
assert pool.getBaseTokenAddress() == OCEAN.address
assert ssbot.getBaseTokenAddress(DT.address) == OCEAN.address
assert ssbot.getBaseTokenBalance(DT.address) == 0
assert ssbot.getPublisherAddress(DT.address) == address0
assert ssbot.getPoolAddress(DT.address) == pool.address
assert fromBase18(ssbot.getvestingAmount(DT.address)) == 1000
# ssbot manages DTs in two specific ways:
# 1. Linear vesting of DTs to publisher over a fixed # blocks
# 2. When OCEAN liquidity is added to the pool, it
# moves DT from its balance into the pool (ultimately, DT circ supply)
# such that DT:OCEAN ratio stays constant
# Therefore: (DT_vested) + (ssbot_DT_balance + DT_circ_supply) = DT_cap
# No blocks have passed since pool creation. Therefore no vesting yet
assert ssbot.getvestingAmountSoFar(DT.address) == 0
# We start out with a given OCEAN_init_liquidity. And, DT_OCEAN_rate is
# the initial DT:OCEAN ratio.
# Therefore we know how many DT the bot was supposed to add to the pool:
# OCEAN_init_liquidity * DT_OCEAN_rate = 2000*0.1 = 200
# Since no one's swapped for DT, then this is also DT circulating supply
assert fromBase18(ssbot.getDatatokenCirculatingSupply(DT.address)) == 200
# The ssbot holds the rest of the DT. Rerrange formula above to see amt.
# So,ssbot_DT_balance = DT_cap - DT_vested - DT_circ_supply
# = 10000 - 0 - 200
# = 9800
assert fromBase18(DT.balanceOf(ssbot.address)) == 9800
# ========================================================
# Test vesting... (recall DT_vest_amt = 1000)
assert fromBase18(ssbot.getvestingAmount(DT.address)) == 1000
# datatoken.deployPool()
# -> call BFactory.newBPool()
# -> call SideStaking.newDatatokenCreated()
# -> emit VestingCreated(datatokenAddress, publisherAddress,
# _datatokens[datatokenAddress].vestingEndBlock,
# _datatokens[datatokenAddress].vestingAmount)
assert ssbot.getAvailableVesting(DT.address) == 0
assert ssbot.getvestingAmountSoFar(DT.address) == 0
# Pass enough time to make all vesting happen!
brownie.chain.mine(blocks=DT_vest_num_blocks)
# Test key numbers
block_number = len(brownie.chain)
vesting_end_block = ssbot.getvestingEndBlock(DT.address)
vesting_last_block = ssbot.getvestingLastBlock(DT.address)
blocks_passed = vesting_end_block - vesting_last_block
available_vesting = fromBase18(ssbot.getAvailableVesting(DT.address))
assert block_number == 616
assert vesting_end_block == 615
assert vesting_last_block == 15 # last block when tokens were vested
assert blocks_passed == 600
assert available_vesting == 1000
# Publisher hasn't claimed yet, so no vesting or DTs
assert ssbot.getvestingAmountSoFar(DT.address) == 0
assert DT.balanceOf(account0) == 0
# Publisher claims. Now he has vesting and DTs
ssbot.getVesting(DT.address, {"from": account0}) # claim!
assert fromBase18(ssbot.getvestingAmountSoFar(DT.address)) == 1000
assert fromBase18(DT.balanceOf(account0)) == 1000
# The ssbot's holdings are updated too
# ssbot_DT_balance = DT_cap - DT_vested - DT_circ_supply
# = 10000 - 1000 - 200
# = 8800
assert fromBase18(ssbot.getDatatokenBalance(DT.address)) == 8800
#
assert ssbot.getvestingLastBlock(DT.address) == 616 == block_number
def BPT(self, pool) -> float:
return fromBase18(self._BPT_base(pool))
def DT(self, dt) -> float:
return fromBase18(self._DT_base(dt))
def ETH(self) -> float:
return fromBase18(self._ETH_base())
def OCEAN(self) -> float:
return fromBase18(self._OCEAN_base())
def netlist_createLogData(state): #pylint: disable=too-many-statements
"""SimEngine constructor uses this"""
s = [] # for console logging
dataheader = [] # for csv logging: list of string
datarow = [] # for csv logging: list of float
# SimEngine already logs: Tick, Second, Min, Hour, Day, Month, Year
# So we log other things...
agents_names = [
"publisher",
# "consumer",
"stakerSpeculator",
"speculator",
# "buySellRobot",
# "maliciousPublisher"
# "erc721"
]
# tracking OCEAN
OCEANtoken = globaltokens.OCEANtoken()
OCEAN_address = globaltokens.OCEAN_address()
for name in agents_names:
agent = state.getAgent(name)
# in wallet
dataheader += [f"{name}_OCEAN"]
datarow += [agent.OCEAN()]
# in DTs
dataheader += [f"{name}_OCEAN_in_DTs"]
datarow += [get_OCEAN_in_DTs(state, agent)]
# in BPTs
dataheader += [f"{name}_OCEAN_in_BPTs"]
datarow += [get_OCEAN_in_BPTs(state, agent)]
# networth
dataheader += [f"{name}_OCEAN_networth"]
datarow += [
agent.OCEAN()
+ get_OCEAN_in_DTs(state, agent)
+ get_OCEAN_in_BPTs(state, agent)
]
dataheader += [f"DT_{name}"]
dataheader += [f"BPT_{name}"]
# Tracking DT and BPT balances of agents
if any(state.agents.filterToPoolV4().values()):
poolAgent_0 = list(state.agents.filterToPoolV4().values())[0]
DT = poolAgent_0._dt
amt_DT = agent.DT(DT)
datarow += [amt_DT]
datarow += [agent.BPT(poolAgent_0._pool)] # agent.BPT(pool)
else:
datarow += [0, 0]
# Track pool0
# 1. DT in pool,
# 2. DT balance of 1ss contract
# 3. BPT total supply,
# 4. BPT balance of 1ss contract,
# 5. DT spot price
# 6. OCEAN in pool
dataheader += ["DT_pool"]
dataheader += ["DT_1ss_contract"]
dataheader += ["BPT_total"]
dataheader += ["BPT_1ss_contract"]
dataheader += ["DT_price"]
dataheader += ["pool_OCEAN"]
if any(state.agents.filterToPoolV4().values()):
poolAgent_0 = list(state.agents.filterToPoolV4().values())[0]
pool0 = poolAgent_0._pool
DT = poolAgent_0._dt
oneSSContractAddress = pool0.getController()
datarow += [fromBase18(DT.balanceOf(pool0.address))] # 1
datarow += [fromBase18(DT.balanceOf(oneSSContractAddress))] # 2
datarow += [fromBase18(pool0.totalSupply())] # 3
datarow += [fromBase18(pool0.balanceOf(oneSSContractAddress))] # 4
swapFee = pool0.getSwapFee()
datarow += [
fromBase18(pool0.getSpotPrice(OCEAN_address, DT.address, swapFee))
] # 5
datarow += [fromBase18(OCEANtoken.balanceOf(pool0.address))]
else:
datarow += [0, 0, 0, 0, 0, 0]
pool_agents = state.agents.filterToPoolV4()
n_pools = len(pool_agents)
s += [f"; # pools={n_pools}"]
dataheader += ["n_pools"]
datarow += [n_pools]
rugged_pool = state.rugged_pools
n_rugged = len(rugged_pool)
# s += [f"; # rugged pools={n_rugged}"]
s += [f"; # block height={brownie.chain.height}"]
dataheader += ["n_rugged"]
datarow += [n_rugged]
return s, dataheader, datarow
def test_setSwapFee_works():
pool = _deployBPool()
pool.setSwapFee(toBase18(0.011), {"from": account0})
assert fromBase18(pool.getSwapFee()) == 0.011
