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_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_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 _createDataconsumerAgent(self, state) -> DataconsumerAgent: name = 'foo' #FIXME USD = 0.0 #FIXME magic number OCEAN = 1000.0 #FIXME magic number new_agent = DataconsumerAgent(name=name, USD=USD, OCEAN=OCEAN) new_agents.add(new_agent)
def _createDataconsumerAgent(self, state) -> None: # pylint: disable=no-self-use name = "foo_dataconsumer" USD = 0.0 # magic number OCEAN = 1000.0 # magic number new_agent = DataconsumerAgent(name=name, USD=USD, OCEAN=OCEAN) state.addAgent(new_agent)
def __init__(self, ss=None): # initialize self.tick, ss, agents, kpis super().__init__(ss) # now, fill in actual values for ss, agents, kpis if self.ss is None: self.ss = SimStrategy() ss = self.ss # for convenience as we go forward # wire up the circuit new_agents: Set[AgentBase.AgentBase] = set() pub_ss = PublisherStrategy( DT_init=self.ss.publisher_DT_init, DT_stake=self.ss.publisher_DT_stake, pool_weight_DT=self.ss.publisher_pool_weight_DT, pool_weight_OCEAN=self.ss.publisher_pool_weight_OCEAN, s_between_create=self.ss.publisher_s_between_create, s_between_unstake=self.ss.publisher_s_between_unstake, s_between_sellDT=self.ss.publisher_s_between_sellDT, is_malicious=False, ) new_agents.add( PublisherAgent( name="publisher", USD=0.0, OCEAN=self.ss.publisher_init_OCEAN, pub_ss=pub_ss, )) new_agents.add( DataconsumerAgent( name="consumer", USD=0.0, OCEAN=self.ss.consumer_init_OCEAN, s_between_buys=self.ss.consumer_s_between_buys, profit_margin_on_consume=self.ss. consumer_profit_margin_on_consume, )) new_agents.add( StakerspeculatorAgent( name="stakerSpeculator", USD=0.0, OCEAN=self.ss.staker_init_OCEAN, s_between_speculates=self.ss.staker_s_between_speculates, )) new_agents.add( SpeculatorAgent( name="speculator", USD=0.0, OCEAN=self.ss.speculator_init_OCEAN, s_between_speculates=self.ss.speculator_s_between_speculates, )) mal_pub_ss = PublisherStrategy( DT_init=self.ss.mal_DT_init, DT_stake=self.ss.mal_DT_stake, pool_weight_DT=self.ss.mal_pool_weight_DT, pool_weight_OCEAN=self.ss.mal_pool_weight_OCEAN, s_between_create=self.ss.mal_s_between_create, s_between_unstake=self.ss.mal_s_between_unstake, s_between_sellDT=self.ss.mal_s_between_sellDT, is_malicious=True, s_wait_to_rug=self.ss.mal_s_wait_to_rug, s_rug_time=self.ss.mal_s_rug_time, ) new_agents.add( PublisherAgent( name="maliciousPublisher", USD=0.0, OCEAN=self.ss.mal_init_OCEAN, pub_ss=mal_pub_ss, )) for agent in new_agents: self.agents[agent.name] = agent # kpis is defined in this netlist module self.kpis = KPIs(self.ss.time_step) # pools that were rug-pulled by a malicious publisher. Some agents # watch for 'state.rugged_pools' and act accordingly. self.rugged_pools: List[str] = []
def test_constructor2(): agent = DataconsumerAgent("agent1", 0.1, 0.2, 3, 0.4) assert agent._s_between_buys == 3 assert agent._profit_margin_on_consume == 0.4
def test_constructor1(): agent = DataconsumerAgent("agent1", 0.1, 0.2) assert agent.USD() == 0.1 assert agent.OCEAN() == 0.2 assert agent._s_between_buys > 0 assert agent._profit_margin_on_consume > 0.0