def test_has_enough_conviction(self):
p = Proposal(500, 0.0)
# a newly created Proposal can't expect to have any Conviction gathered at all
self.assertFalse(p.has_enough_conviction(10000, 3e6, 0.2))
p.conviction = 2666666.7
self.assertTrue(p.has_enough_conviction(10000, 3e6, 0.2))
def test_get_proposals(self):
res = get_proposals(self.network)
self.assertEqual(len(res), 5)
proposal = Proposal(10, 5)
proposal.status = ProposalStatus.ACTIVE
self.network.add_node(len(self.network.nodes), item=proposal)
res = get_proposals(self.network, status=ProposalStatus.ACTIVE)
self.assertEqual(len(res), 1)
def setUp(self):
self.params = {
"debug": False,
"days_to_80p_of_max_voting_weight": 10,
"probability_func": new_probability_func(seed=None),
"exponential_func": new_exponential_func(seed=None),
"gamma_func": new_gamma_func(seed=None),
"random_number_func": new_random_number_func(seed=None)
}
self.network = bootstrap_network([
TokenBatch(1000, 0, vesting_options=VestingOptions(10, 30))
for _ in range(4)
], 1, 3000, 4e6, 0.2, self.params["probability_func"],
self.params["random_number_func"],
self.params["gamma_func"],
self.params["exponential_func"])
self.network, _ = add_proposal(self.network, Proposal(100, 1),
self.params["random_number_func"])
"""
For proper testing, we need to make sure the Proposals are CANDIDATE and
ensure Proposal-Participant affinities are not some random value
"""
self.network.nodes[4]["item"].status = ProposalStatus.CANDIDATE
self.network.nodes[5]["item"].status = ProposalStatus.CANDIDATE
support_edges = get_edges_by_type(self.network, "support")
for u, v in support_edges:
self.network[u][v]["support"] = self.network[u][v][
"support"]._replace(affinity=0.9)
def su_add_to_network(params, step, sL, s, _input, **kwargs):
network = s["network"]
funding_pool = s["funding_pool"]
token_supply = s["token_supply"]
gamma_func = params["gamma_func"]
random_number_func = params["random_number_func"]
if _input["new_proposal"]:
# Create the Proposal and add it to the network.
rescale = funding_pool * config.scale_factor
r_rv = gamma_func(config.funds_requested_alpha,
loc=config.funds_requested_min,
scale=rescale)
proposal = Proposal(funds_requested=r_rv,
trigger=trigger_threshold(
r_rv, funding_pool, token_supply,
params["max_proposal_request"]))
network, proposal_idx = add_proposal(network, proposal,
random_number_func)
# add_proposal() has created support edges from other Participants
# to this Proposal. If the Participant is the one who created this
# Proposal, set the participant's role as author and change his affinity for the Proposal to 1 (maximum).
network.edges[_input["proposed_by_participant"],
proposal_idx]["support"] = \
network.edges[_input["proposed_by_participant"], proposal_idx]["support"]._replace(affinity=1, is_author=True)
if params.get("debug"):
print(
"GenerateNewProposal: Participant {} created Proposal {}".
format(_input["proposed_by_participant"], proposal_idx))
return "network", network
def setUp(self):
self.params = {
"debug": True,
"probability_func": new_probability_func(seed=None),
"exponential_func": new_exponential_func(seed=None),
"gamma_func": new_gamma_func(seed=None),
"random_number_func": new_random_number_func(seed=None)
}
vesting_participants = [
TokenBatch(1000, 1000, vesting_options=VestingOptions(10, 30))
for _ in range(2)
]
nonvesting_participants = [
TokenBatch(0, 1000, vesting_options=VestingOptions(10, 30))
for _ in range(2)
]
self.network = bootstrap_network(
vesting_participants + nonvesting_participants, 1, 3000, 4e6, 0.2,
self.params["probability_func"], self.params["random_number_func"],
self.params["gamma_func"], self.params["exponential_func"])
self.commons = Commons(1000, 1000)
self.network, _ = add_proposal(self.network, Proposal(100, 1),
self.params["random_number_func"])
self.default_state = {
"network": self.network,
"commons": self.commons,
"funding_pool": 1000,
"token_supply": 1000
}
def su_add_to_network(params, step, sL, s, _input, **kwargs):
network = s["network"]
funding_pool = s["funding_pool"]
token_supply = s["token_supply"]
gamma_func = params["gamma_func"]
random_number_func = params["random_number_func"]
if _input["new_proposal"]:
proposed_by = _input["proposed_by_participant"]
# Create the Proposal and add it to the network.
rescale = funding_pool * config.scale_factor
r_rv = gamma_func(config.funds_requested_alpha,
loc=config.funds_requested_min,
scale=rescale)
proposal = Proposal(funds_requested=r_rv,
trigger=trigger_threshold(
r_rv, funding_pool, token_supply,
params["max_proposal_request"]))
network, proposal_idx = add_proposal(network, proposal,
proposed_by,
random_number_func)
if params.get("debug"):
print(
"GenerateNewProposal: Participant {} created Proposal {}".
format(_input["proposed_by_participant"], proposal_idx))
return "network", network
def su_add_to_network(params, step, sL, s, _input, **kwargs):
network = s["network"]
funding_pool = s["funding_pool"]
token_supply = s["token_supply"]
scale_factor = 0.01
if _input["new_proposal"]:
# Create the Proposal and add it to the network.
rescale = funding_pool * scale_factor
r_rv = gamma.rvs(3, loc=0.001, scale=rescale)
proposal = Proposal(funds_requested=r_rv,
trigger=trigger_threshold(
r_rv, funding_pool, token_supply,
params["max_proposal_request"]))
network, proposal_idx = add_proposal(network, proposal)
# add_proposal() has created support edges from other Participants
# to this Proposal. If the Participant is the one who created this
# Proposal, change his affinity for the Proposal to 1 (maximum).
network.edges[_input["proposed_by_participant"],
proposal_idx]["affinity"] = 1
if params.get("debug"):
print(
"GenerateNewProposal: Participant {} created Proposal {}".
format(_input["proposed_by_participant"], proposal_idx))
return "network", network
def setUp(self):
self.network = bootstrap_network(
[TokenBatch(1000, VestingOptions(10, 30)) for _ in range(4)], 1,
3000, 4e6)
self.network, _ = add_proposal(self.network, Proposal(100, 1))
self.network.nodes[4]["item"].status = ProposalStatus.ACTIVE
self.network.nodes[5]["item"].status = ProposalStatus.ACTIVE
def test_add_proposal(self):
"""
This test ensures that the Proposal was added and that
setup_conflict_edges() was executed for that particular node.
"""
n1, j = add_proposal(self.network, Proposal(23, 111))
self.assertEqual(n1.nodes[j]["item"].funds_requested, 23)
self.assertEqual(n1.nodes[j]["item"].trigger, 111)
self.assertEqual(len(n1.edges), 5)
for u, v, t in n1.edges(data="type"):
self.assertEqual(v, 10)
self.assertEqual(t, "support")
self.assertIn(u, [0, 2, 4, 6, 8])
def setUp(self):
self.network = bootstrap_network([
TokenBatch(1000, 0, vesting_options=VestingOptions(10, 30))
for _ in range(4)
], 1, 3000, 4e6, 0.2)
self.network, _ = add_proposal(self.network, Proposal(100, 1))
self.network.nodes[4]["item"].status = ProposalStatus.CANDIDATE
self.network.nodes[5]["item"].status = ProposalStatus.CANDIDATE
self.params = {
"max_proposal_request": 0.2,
"alpha_days_to_80p_of_max_voting_weight": 10
}
def setUp(self):
self.network = bootstrap_network([
TokenBatch(1000, 1000, vesting_options=VestingOptions(10, 30))
for _ in range(4)
], 1, 3000, 4e6, 0.2)
self.commons = Commons(1000, 1000)
self.network, _ = add_proposal(self.network, Proposal(100, 1))
self.params = {"debug": True}
self.default_state = {
"network": self.network,
"commons": self.commons,
"funding_pool": 1000,
"token_supply": 1000
}
def setUp(self):
self.network = nx.DiGraph()
self.params = {
"probability_func": new_probability_func(seed=None),
"exponential_func": new_exponential_func(seed=None),
"gamma_func": new_gamma_func(seed=None),
"random_number_func": new_random_number_func(seed=None)
}
for i in range(0, 10, 2):
self.network.add_node(i,
item=Participant(
TokenBatch(0, 0),
self.params["probability_func"],
self.params["random_number_func"]))
self.network.add_node(i + 1, item=Proposal(10, 5))
def bootstrap_network(n_participants: List[TokenBatch], n_proposals: int, funding_pool: float, token_supply: float, max_proposal_request: float, probability_func, random_number_func, gamma_func, exponential_func) -> nx.DiGraph:
"""
Convenience function that creates a network ready for simulation in
the Python notebook in one line.
"""
n = create_network(n_participants, probability_func, random_number_func)
for _ in range(n_proposals):
idx = len(n)
r_rv = gamma_func(3, loc=0.001, scale=10000)
n.add_node(idx, item=Proposal(funds_requested=r_rv, trigger=trigger_threshold(
r_rv, funding_pool, token_supply, max_proposal_request)))
n = setup_support_edges(n, random_number_func)
n = setup_conflict_edges(n, random_number_func)
# n = setup_influence_edges_bulk(n, exponential_func) # TODO: Disabled as these aren't being used on any model policy
return n
def setUp(self):
self.network = bootstrap_network([
TokenBatch(1000, 0, vesting_options=VestingOptions(10, 30))
for _ in range(4)
], 1, 3000, 4e6, 0.2)
self.network, _ = add_proposal(self.network, Proposal(100, 1))
self.params = {"debug": False, "days_to_80p_of_max_voting_weight": 10}
"""
For proper testing, we need to make sure the Proposals are CANDIDATE and
ensure Proposal-Participant affinities are not some random value
"""
self.network.nodes[4]["item"].status = ProposalStatus.CANDIDATE
self.network.nodes[5]["item"].status = ProposalStatus.CANDIDATE
support_edges = get_edges_by_type(self.network, "support")
for u, v in support_edges:
self.network[u][v]["affinity"] = 0.9
def bootstrap_network(n_participants: List[TokenBatch], n_proposals: int, funding_pool: float, token_supply: float, max_proposal_request: float) -> nx.DiGraph:
"""
Convenience function that creates a network ready for simulation in
the Python notebook in one line.
"""
n = create_network(n_participants)
for _ in range(n_proposals):
idx = len(n)
r_rv = gamma.rvs(3, loc=0.001, scale=10000)
n.add_node(idx, item=Proposal(funds_requested=r_rv, trigger=trigger_threshold(
r_rv, funding_pool, token_supply, max_proposal_request)))
n = setup_support_edges(n)
n = setup_conflict_edges(n)
n = setup_influence_edges_bulk(n)
return n
def su_add_to_network(params, step, sL, s, _input):
network = s["network"]
funding_pool = s["funding_pool"]
token_supply = s["token_supply"]
scale_factor = 0.01
if _input["new_proposal"]:
# Create the Proposal and add it to the network.
rescale = funding_pool * scale_factor
r_rv = gamma.rvs(3, loc=0.001, scale=rescale)
proposal = Proposal(funds_requested=r_rv,
trigger=convictionvoting.trigger_threshold(r_rv, funding_pool, token_supply))
network, j = add_proposal(network, proposal)
# add_proposal() has created support edges from other Participants
# to this Proposal. If the Participant is the one who created this
# Proposal, change his affinity for the Proposal to 1 (maximum).
network.edges[_input["proposed_by_participant"], j]["affinity"] = 1
return "network", network
def setUp(self):
self.params = {
"probability_func": new_probability_func(seed=None),
"exponential_func": new_exponential_func(seed=None),
"gamma_func": new_gamma_func(seed=None),
"random_number_func": new_random_number_func(seed=None)
}
self.network = bootstrap_network([
TokenBatch(1000, 0, vesting_options=VestingOptions(10, 30))
for _ in range(4)
], 1, 3000, 4e6, 0.2, self.params["probability_func"],
self.params["random_number_func"],
self.params["gamma_func"],
self.params["exponential_func"])
self.network, _ = add_proposal(self.network, Proposal(100, 1),
self.params["random_number_func"])
self.network.nodes[4]["item"].status = ProposalStatus.ACTIVE
self.network.nodes[5]["item"].status = ProposalStatus.ACTIVE
def setUp(self):
self.params = {
"max_proposal_request": 0.2,
"alpha_days_to_80p_of_max_voting_weight": 10,
"probability_func": new_probability_func(seed=None),
"exponential_func": new_exponential_func(seed=None),
"gamma_func": new_gamma_func(seed=None),
"random_number_func": new_random_number_func(seed=None)
}
self.commons = Commons(1000, 1000)
self.network = bootstrap_network([
TokenBatch(1000, 0, vesting_options=VestingOptions(10, 30))
for _ in range(4)
], 1, 3000, 4e6, 0.2, self.params["probability_func"],
self.params["random_number_func"],
self.params["gamma_func"],
self.params["exponential_func"])
self.network, _ = add_proposal(self.network, Proposal(100, 1),
self.params["random_number_func"])
self.network.nodes[4]["item"].status = ProposalStatus.CANDIDATE
self.network.nodes[5]["item"].status = ProposalStatus.CANDIDATE
def test_stake_across_all_supported_proposals(self):
"""
Test that the rebalancing code works as intended.
Given 4 Proposals which the Participant has affinity 0.9, 0.9, 0.8, 0.6
to, we should expect an allocation of 0.28125, 0.28125, 02.5, 0.1872
respectively.
The calculation should also include vesting and nonvesting TokenBatches.
"""
p = [Proposal(0, 0) for _ in range(4)]
p[0].uuid = uuid.UUID(int=179821351946450230734044638685583215499)
p[1].uuid = uuid.UUID(int=215071290061070589371009813111193284959)
p[2].uuid = uuid.UUID(int=20468923874830131214536379780280861909)
p[3].uuid = uuid.UUID(int=268821512376988039567204465930241984322)
supported_proposals = [
(0.9, p[0]),
(0.9, p[1]),
(0.8, p[2]),
(0.6, p[3]),
]
self.p.holdings_vesting = TokenBatch(500)
self.p.holdings_nonvesting = TokenBatch(500)
ans = self.p.stake_across_all_supported_proposals(supported_proposals)
print(ans)
self.assertEqual(
ans[uuid.UUID(int=179821351946450230734044638685583215499)], 281.25000000000006)
self.assertEqual(
ans[uuid.UUID(int=215071290061070589371009813111193284959)], 281.25000000000006)
self.assertEqual(
ans[uuid.UUID(int=20468923874830131214536379780280861909)], 250.00000000000006)
self.assertEqual(
ans[uuid.UUID(int=268821512376988039567204465930241984322)], 187.5)
class TestProposal(unittest.TestCase):
def setUp(self):
self.p = Proposal(500, 0.0)
def test_update_age(self):
self.p.update_age()
# The Proposal's age starts at 0 and should be incremented by 1 after update_age()
self.assertEqual(self.p.age, 1)
def test_update_threshold(self):
# Just check if the trigger_threshold is correct
self.assertEqual(self.p.update_threshold(500000.0, 3000.0, 10000.0), 1500.000300000045)
# If the proposal status is not CANDIDATE, update_threshold shoud return NaN
self.p.status = ProposalStatus.ACTIVE
self.assertTrue(math.isnan(self.p.update_threshold(500000.0, 3000.0, 10000.0)))
def test_has_enough_conviction(self):
# a newly created Proposal can't expect to have any Conviction gathered at all
self.assertFalse(self.p.has_enough_conviction(10000, 3e6, 0.2))
self.p.conviction = 2666666.7
self.assertTrue(self.p.has_enough_conviction(10000, 3e6, 0.2))
def setUp(self):
self.network = nx.DiGraph()
for i in range(0, 10, 2):
self.network.add_node(i, item=Participant(TokenBatch(0, 0)))
self.network.add_node(i + 1, item=Proposal(10, 5))
def setUp(self):
self.p = Proposal(500, 0.0)
