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