logos-blockchain/logos-blockchain-specs
1
0
Fork 0
mirror of https://github.com/logos-blockchain/logos-blockchain-specs.git synced 2026-01-03 21:53:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

DeclarationId to ProviderId

Browse Source
This commit is contained in:
danielSanchezQ 2025-07-17 07:34:06 +00:00
parent c763d47339
commit 198f8c273d
2 changed files with 19 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
da/assignations/refill.py
View File

@ -7,23 +7,23 @@ from collections import Counter
from heapq import heappush, heappop, heapify
DeclarationId: TypeAlias = bytes
Assignations: TypeAlias = List[Set[DeclarationId]]
ProviderId: TypeAlias = bytes
Assignations: TypeAlias = List[Set[ProviderId]]
BlakeRng: TypeAlias = Any
@dataclass(order=True)
class Participant:
# Participant's wrapper class
# Used for keeping ordering in the heap by the participation first and the declaration id second
# Used for keeping ordering in the heap by the participation first and the provider id second
participation: int # prioritize participation count first
declaration_id: DeclarationId # sort by id on default
provider_id: ProviderId # sort by id on default
@dataclass
class Subnetwork:
# Subnetwork wrapper that keeps the subnetwork id [0..2048) and the set of participants in that subnetwork
participants: Set[DeclarationId]
participants: Set[ProviderId]
subnetwork_id: int
def __lt__(self, other):
@ -47,7 +47,7 @@ def all_nodes_assigned(participants: Sequence[Participant], average_participatio
def heappop_next_for_subnetwork(subnetwork: Subnetwork, participants: List[Participant]) -> Participant:
poped = []
participant = heappop(participants)
while participant.declaration_id in subnetwork.participants:
while participant.provider_id in subnetwork.participants:
poped.append(participant)
participant = heappop(participants)
for poped in poped:
@ -79,11 +79,11 @@ def fill_subnetworks(
# take the fewest participants subnetwork
subnetwork = heappop(subnetworks)
# take the declaration with the lowest participation that is not included in the subnetwork
# take the provider with the lowest participation that is not included in the subnetwork
participant = heappop_next_for_subnetwork(subnetwork, available_nodes)
# fill into subnetwork
subnetwork.participants.add(participant.declaration_id)
subnetwork.participants.add(participant.provider_id)
participant.participation += 1
# push to heaps
heappush(available_nodes, participant)
@ -112,11 +112,11 @@ def balance_subnetworks_grow(
):
for participant in filter(lambda x: x.participation > average_participation, sorted(participants)):
for subnework in sample(
sorted(filter(lambda subnetwork: participant.declaration_id in subnetwork.participants, subnetworks)),
sorted(filter(lambda subnetwork: participant.provider_id in subnetwork.participants, subnetworks)),
random,
k=participant.participation - average_participation
):
subnework.participants.remove(participant.declaration_id)
subnework.participants.remove(participant.provider_id)
participant.participation -= 1
@ -129,7 +129,7 @@ def rand(seed: bytes):
def calculate_subnetwork_assignations(
new_nodes_list: Sequence[DeclarationId],
new_nodes_list: Sequence[ProviderId],
previous_subnets: Assignations,
replication_factor: int,
random_seed: bytes,
@ -146,7 +146,7 @@ def calculate_subnetwork_assignations(
# 1) For each (sorted) participant, remove the participant from random subnetworks (coming from sorted list)
# until the participation of is equal to the average participation.
# 4. Create a heap with the set of active nodes ordered by, primary the number of subnetworks each participant is at
# and secondary by the DeclarationId of the participant (ascending order).
# and secondary by the ProviderId of the participant (ascending order).
# 5. Create a heap with the subnetworks ordered by the number of participants in each subnetwork
# 6. Until all subnetworks are filled up to a replication factor and all nodes are assigned:
# 1) pop the subnetwork with the fewest participants
@ -169,11 +169,11 @@ def calculate_subnetwork_assignations(
active_assignations = [subnet - unavailable_nodes for subnet in previous_subnets]
# count participation per assigned node
assigned_count: Counter[DeclarationId] = Counter(chain.from_iterable(active_assignations))
assigned_count: Counter[ProviderId] = Counter(chain.from_iterable(active_assignations))
# available nodes heap
available_nodes = [
Participant(participation=assigned_count.get(_id, 0), declaration_id=_id) for _id in new_nodes
Participant(participation=assigned_count.get(_id, 0), provider_id=_id) for _id in new_nodes
]
# subnetworks heap

10
da/assignations/test_refill.py
View File

@ -2,7 +2,7 @@ import random
from itertools import chain
from typing import List, Counter
from unittest import TestCase
from da.assignations.refill import calculate_subnetwork_assignations, Assignations, DeclarationId
from da.assignations.refill import calculate_subnetwork_assignations, Assignations, ProviderId
class TestRefill(TestCase):
@ -71,21 +71,21 @@ class TestRefill(TestCase):
@classmethod
def mutate_nodes(cls, nodes: List[DeclarationId], count: int):
def mutate_nodes(cls, nodes: List[ProviderId], count: int):
assert count < len(nodes)
for i in random.choices(list(range(len(nodes))), k=count):
nodes[i] = random.randbytes(32)
@classmethod
def expand_nodes(cls, nodes: List[DeclarationId], count: int) -> List[DeclarationId]:
def expand_nodes(cls, nodes: List[ProviderId], count: int) -> List[ProviderId]:
return [*nodes, *(random.randbytes(32) for _ in range(count))]
@classmethod
def shrink_nodes(cls, nodes: List[DeclarationId], count: int) -> List[DeclarationId]:
def shrink_nodes(cls, nodes: List[ProviderId], count: int) -> List[ProviderId]:
return list(random.sample(nodes, k=count))
def assert_assignations(self, assignations: Assignations, nodes: List[DeclarationId], replication_factor: int):
def assert_assignations(self, assignations: Assignations, nodes: List[ProviderId], replication_factor: int):
self.assertEqual(
len(set(chain.from_iterable(assignations))),
len(nodes),