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)