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)