def test_speculateAction_with_good_pools(alice_info, _AgentClass):
alice_pool = alice_info.pool
state = MockState()
state.agents["pool1"] = PoolAgent("pool1", alice_pool)
agent = _AgentClass("agent1", USD=0.0, OCEAN=500.0)
assert agent._poolsForSpeculate(state)
assert not agent._doSpeculateAction(state) # not enough time passsed
agent._s_since_speculate += agent._s_between_speculates # make time pass
assert agent._doSpeculateAction(state) # now, enough time passed
dt = state.agents["pool1"].datatoken
assert agent.OCEAN() == 500.0
if _AgentClass == SpeculatorAgent:
assert agent.DT(dt) == 0.0
else:
assert agent.BPT(alice_pool) == 0.0
agent._speculateAction(state)
assert agent.OCEAN() < 500.0
if _AgentClass == SpeculatorAgent:
assert agent.DT(dt) > 0.0
else:
assert agent.BPT(alice_pool) > 0.0
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 test_buyAndConsumeDT(alice_info):
state = MockState()
publisher_agent = SimpleAgent("agent1", USD=0.0, OCEAN=0.0)
publisher_agent._wallet = alice_info.agent._wallet
state.addAgent(publisher_agent)
OCEAN_before = 1000.0
consumer_agent = DataconsumerAgent("consumer1", USD=0.0, OCEAN=OCEAN_before)
consumer_agent._s_since_buy += consumer_agent._s_between_buys
state.addAgent(consumer_agent)
pool_agent = PoolAgent("pool1", alice_info.pool)
state.addAgent(pool_agent)
assert state.agents.filterToPool().values() # have pools
assert consumer_agent._candPoolAgents(state) # have useful pools
assert consumer_agent._doBuyAndConsumeDT(state)
# buyAndConsumeDT
dt = state.agents["pool1"].datatoken
assert consumer_agent.OCEAN() == OCEAN_before
assert consumer_agent.DT(dt) == 0.0
OCEAN_spend = consumer_agent._buyAndConsumeDT(state)
OCEAN_after = consumer_agent.OCEAN()
OCEAN_gained = OCEAN_spend * (1.0 + consumer_agent._profit_margin_on_consume)
assert OCEAN_after == approx(OCEAN_before - OCEAN_spend + OCEAN_gained)
assert consumer_agent.DT(dt) == 0.0 # bought 1.0, then consumed it
# consumeDT
assert state.agents.agentByAddress(pool_agent.controller_address)
def test_speculateAction_withpools(alice_pool):
state = MockState()
state.agents["pool1"] = PoolAgent("pool1", alice_pool)
agent = StakerspeculatorAgent("agent1", USD=0.0, OCEAN=500.0)
assert agent.OCEAN() == 500.0
assert agent.BPT(alice_pool) == 0.0
agent._speculateAction(state)
assert agent.OCEAN() < 500.0
assert agent.BPT(alice_pool) > 0.0
def test_speculateAction_with_rugged_pools(alice_info, _AgentClass):
alice_pool = alice_info.pool
state = MockState()
state.agents["pool1"] = PoolAgent("pool1", alice_pool)
state.rugged_pools = ["pool1"] # pylint: disable=attribute-defined-outside-init
agent = _AgentClass("agent1", USD=0.0, OCEAN=500.0)
assert not agent._poolsForSpeculate(state)
assert not agent._doSpeculateAction(state)
with pytest.raises(AssertionError):
agent._speculateAction(state) # error because no good pools
def test_doBuyAndConsumeDT_have_rugged_pools(alice_info):
alice_pool = alice_info.pool
state = MockState()
agent = DataconsumerAgent("agent1", USD=0.0, OCEAN=1000.0)
agent._s_since_buy += agent._s_between_buys
state.agents["pool1"] = PoolAgent("pool1", alice_pool)
assert agent._candPoolAgents(state) # have useful pools
state.rugged_pools = ["pool1"] # pylint: disable=attribute-defined-outside-init
assert not agent._candPoolAgents(state) # do _not_ have useful pools
def test_take_step(alice_pool):
state = MockState()
state.agents["pool1"] = PoolAgent("pool1", alice_pool)
agent = StakerspeculatorAgent("agent1", USD=0.0, OCEAN=500.0)
num_speculates = num_loops = 0
while num_speculates < 5 and num_loops < 10000:
agent.takeStep(state)
if num_loops > 0 and agent._s_since_speculate == 0:
num_speculates += 1
num_loops += 1
assert num_speculates > 0, "should have had at least one speculate"
def _createPoolAgent(self, state) -> PoolAgent:
assert self.OCEAN() > 0.0, "should not call if no OCEAN"
account = self._wallet._account
OCEAN = globaltokens.OCEANtoken()
# name
pool_i = len(state.agents.filterToPool())
dt_name = f"DT{pool_i}"
pool_agent_name = f"pool{pool_i}"
# new DT
DT = self._createDatatoken(dt_name, mint_amt=self.pub_ss.DT_init)
# new pool
pool = oceanv3util.newBPool(account)
# bind tokens & add initial liquidity
OCEAN_bind_amt = max(0,
self.OCEAN() -
1.0) # magic number: use most OCEAN
DT_bind_amt = self.pub_ss.DT_stake
DT.approve(pool.address, toBase18(DT_bind_amt), {"from": account})
OCEAN.approve(pool.address, toBase18(OCEAN_bind_amt),
{"from": account})
pool.bind(
DT.address,
toBase18(DT_bind_amt),
toBase18(self.pub_ss.pool_weight_DT),
{"from": account},
)
pool.bind(
OCEAN.address,
toBase18(OCEAN_bind_amt),
toBase18(self.pub_ss.pool_weight_OCEAN),
{"from": account},
)
pool.finalize({"from": account})
# create agent
pool_agent = PoolAgent(pool_agent_name, pool)
state.addAgent(pool_agent)
self._wallet.resetCachedInfo()
# update self.pools
self.pools.append(pool_agent.name)
return pool_agent
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_doSpeculateAction(alice_pool):
state = MockState()
agent = StakerspeculatorAgent("agent1", USD=0.0, OCEAN=0.0)
assert agent._s_since_speculate == 0
assert agent._s_between_speculates > 0
assert not agent._doSpeculateAction(state)
agent._s_since_speculate += agent._s_between_speculates
assert not state.agents.filterToPool().values()
assert not agent._doSpeculateAction(state) #still no, since no pools
state.agents["pool1"] = PoolAgent("pool1", alice_pool)
assert state.agents.filterToPool().values()
assert agent._doSpeculateAction(state)
def test_doBuy(alice_pool):
state = MockState()
agent = DataconsumerAgent("agent1", USD=0.0, OCEAN=1000.0)
assert agent._s_since_buy == 0
assert agent._s_between_buys > 0
assert not agent._doBuy(state)
agent._s_since_buy += agent._s_between_buys
assert not state.agents.filterToPool().values()
assert not agent._doBuy(state) #still no, since no pools
state.agents["pool1"] = PoolAgent("pool1", alice_pool)
assert state.agents.filterToPool().values() #have pools
assert agent._candPoolAgents(state) #have useful pools
assert agent._doBuy(state)
def _createPoolAgent(self, state) -> PoolAgent:
assert self.OCEAN() > 0.0, "should not call if no OCEAN"
wallet = self._wallet._web3wallet
OCEAN = globaltokens.OCEANtoken()
#name
pool_i = len(state.agents.filterToPool())
dt_name = f'DT{pool_i}'
pool_agent_name = f'pool{pool_i}'
#new DT
DT = self._createDatatoken(dt_name, mint_amt=1000.0) #magic number
#new pool
pool_address = bfactory.BFactory().newBPool(from_wallet=wallet)
pool = bpool.BPool(pool_address)
#bind tokens & add initial liquidity
OCEAN_bind_amt = self.OCEAN() #magic number: use all the OCEAN
DT_bind_amt = 20.0 #magic number
DT.approve(pool.address, toBase18(DT_bind_amt), from_wallet=wallet)
OCEAN.approve(pool.address,
toBase18(OCEAN_bind_amt),
from_wallet=wallet)
pool.bind(DT.address,
toBase18(DT_bind_amt),
toBase18(POOL_WEIGHT_DT),
from_wallet=wallet)
pool.bind(OCEAN.address,
toBase18(OCEAN_bind_amt),
toBase18(POOL_WEIGHT_OCEAN),
from_wallet=wallet)
pool.finalize(from_wallet=wallet)
#create agent
pool_agent = PoolAgent(pool_agent_name, pool)
state.addAgent(pool_agent)
self._wallet.resetCachedInfo()
return pool_agent
def test_doSpeculateAction(alice_info, _AgentClass):
alice_pool = alice_info.pool
state = MockState()
agent = _AgentClass("agent1", USD=0.0, OCEAN=0.0, s_between_speculates=1000)
assert agent._s_since_speculate == 0
assert agent._s_between_speculates == 1000
assert not agent._doSpeculateAction(state)
agent._s_since_speculate += agent._s_between_speculates
assert not state.agents.filterToPool().values()
assert not agent._doSpeculateAction(state) # still no, since no pools
state.agents["pool1"] = PoolAgent("pool1", alice_pool)
assert state.agents.filterToPool().values()
assert agent._doSpeculateAction(state)