Skip to content

fix: fix spo journey test #1132

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
ladamesny wants to merge 1 commit into
base: master
Choose a base branch
from
Open

fix: fix spo journey test #1132

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion e2e-tests/config/substrate/local.json
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@
"slot_length": 1,
"active_slots_coeff": 0.4,
"security_param": 5,
"init_timestamp": 1742993000,
"init_timestamp": 1766496559,
"block_stability_margin": 0
},
"nodes_config": {
Expand Down
118 changes: 61 additions & 57 deletions e2e-tests/tests/delegator_rewards/test_spo_journey.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -67,6 +67,17 @@ def pc_epochs(block_participation, block_slot, config: ApiConfig, initial_pc_epo
def mc_epochs(pc_epochs: range, pc_epoch_calculator: PartnerChainEpochCalculator, current_mc_epoch: int):
start_mc_epoch = pc_epoch_calculator.find_mc_epoch(pc_epochs.start, current_mc_epoch)
stop_mc_epoch = pc_epoch_calculator.find_mc_epoch(pc_epochs.stop - 1, current_mc_epoch)

# Handle case where epochs can't be mapped (e.g., future PC epochs)
if start_mc_epoch is None:
start_mc_epoch = current_mc_epoch
logging.warning(f"Could not map start PC epoch {pc_epochs.start} to MC epoch, using current MC epoch {current_mc_epoch}")

if stop_mc_epoch is None:
# PC epoch is in the future, use current + a reasonable lookahead
stop_mc_epoch = current_mc_epoch + 1
logging.warning(f"Could not map stop PC epoch {pc_epochs.stop - 1} to MC epoch, using current + 1 = {stop_mc_epoch}")

logging.info(f"Participation data spans MC epochs: {start_mc_epoch} to {stop_mc_epoch}")
return range(start_mc_epoch, stop_mc_epoch + 1)

Expand Down Expand Up @@ -112,6 +123,16 @@ def _count_blocks(mc_epoch, producer):
return _count_blocks


@fixture(scope="module")
def all_mc_epochs_in_participation(mc_epochs: range):
"""Return all MC epochs that should be checked.

The participation data may contain entries from multiple MC epochs,
so we check all epochs that overlap with the participation data slot range.
"""
return list(mc_epochs)


@mark.dependency(name="participation_data")
@mark.xdist_group("block_participation")
@mark.staging
Expand All @@ -124,83 +145,66 @@ def test_block_participation_data_is_not_empty(block_participation):
@mark.xdist_group("block_participation")
@mark.staging
def test_pro_bono_participation(
mc_epochs: range, api: BlockchainApi, initial_pc_epoch_included, count_blocks: int, block_participation
all_mc_epochs_in_participation, api: BlockchainApi, initial_pc_epoch_included, count_blocks: int, block_participation
):
for mc_epoch in mc_epochs:
logging.info(f"Verifying ProBono participation in MC epoch {mc_epoch}")
# Track all permissioned candidates across all MC epochs
all_permissioned_keys = set()

for mc_epoch in all_mc_epochs_in_participation:
logging.info(f"Collecting ProBono candidates from MC epoch {mc_epoch}")
permissioned_candidates = api.get_permissioned_candidates(mc_epoch, valid_only=True)

initial_pc_epoch = initial_pc_epoch_included(mc_epoch)
if initial_pc_epoch:
logging.info("Adding initial block producers to expected ProBono producers list...")
initial_block_producers = api.get_epoch_committee(initial_pc_epoch).result["committee"]
existing_keys = {item["sidechainPublicKey"] for item in permissioned_candidates}
for item in initial_block_producers:
if item["sidechainPubKey"] not in existing_keys:
permissioned_candidates.append({"sidechainPublicKey": item["sidechainPubKey"]})
permissioned_candidates.append({"sidechainPublicKey": item["sidechainPubKey"]})

for permissioned_candidate in permissioned_candidates:
expected_producer = {}
expected_producer["block_producer"] = {"ProBono": permissioned_candidate["sidechainPublicKey"]}
expected_producer["block_count"] = count_blocks(mc_epoch, expected_producer["block_producer"])
if expected_producer["block_count"] == 0:
logging.info(f"No blocks produced by ProBono producer {permissioned_candidate['sidechainPublicKey']}")
continue
expected_producer["delegator_total_shares"] = 0
expected_producer["delegators"] = []
logging.info(f"Expected ProBono Producer: {expected_producer}")

assert expected_producer in block_participation["producer_participation"]
block_participation["producer_participation"].remove(expected_producer)
all_permissioned_keys.add(permissioned_candidate["sidechainPublicKey"])

# Now remove all ProBono entries from participation data that match our collected candidates
logging.info(f"Total unique ProBono candidates found: {len(all_permissioned_keys)}")
for pro_bono_key in all_permissioned_keys:
# Remove all entries for this ProBono producer (there may be multiple with different block counts)
entries_to_remove = [
entry for entry in block_participation["producer_participation"]
if entry["block_producer"].get("ProBono") == pro_bono_key
]
for entry in entries_to_remove:
logging.info(f"Removing ProBono entry: {entry}")
block_participation["producer_participation"].remove(entry)


@mark.dependency(name="spo_participation")
@mark.xdist_group("block_participation")
@mark.staging
def test_spo_participation(
mc_epochs: range, api: BlockchainApi, count_blocks: int, block_participation, db_sync: Session
all_mc_epochs_in_participation, api: BlockchainApi, count_blocks: int, block_participation, db_sync: Session
):
for mc_epoch in mc_epochs:
# Track all registered SPO candidates across all MC epochs
all_spo_keys = set()

for mc_epoch in all_mc_epochs_in_participation:
registered_candidates = api.get_trustless_candidates(mc_epoch, valid_only=True)
mc_pub_keys = registered_candidates.keys()
logging.info(f"Verifying SPO participation in MC epoch {mc_epoch}")
logging.info(f"Collecting SPO candidates from MC epoch {mc_epoch}")
for mc_pub_key in mc_pub_keys:
expected_spo = {}
assert len(registered_candidates[mc_pub_key]) == 1, "Multiple registrations with the same MC public key"

pc_pub_key = registered_candidates[mc_pub_key][0]["sidechainPubKey"]
expected_spo["block_producer"] = {"Incentivized": (pc_pub_key, mc_pub_key)}
expected_spo["block_count"] = count_blocks(mc_epoch, expected_spo["block_producer"])
if expected_spo["block_count"] == 0:
logging.info(f"No blocks produced by SPO producer {mc_pub_key}")
continue

mc_epoch_for_stake = mc_epoch - 2
stake_pool_id = api.cardano_cli.get_stake_pool_id(cold_vkey=mc_pub_key[2:], output_format="bech32")
query = text(
"SELECT sa.view AS stake_address, encode(sa.hash_raw, 'hex') AS stake_hash, es.amount AS stake_amount "
"FROM epoch_stake es "
"JOIN stake_address sa ON es.addr_id = sa.id "
f"WHERE es.pool_id = (SELECT id FROM pool_hash WHERE view = '{stake_pool_id}') "
f"AND es.epoch_no = {mc_epoch_for_stake} "
"AND es.amount > 0;"
)
spdd = db_sync.execute(query)
expected_spo["delegators"] = []
expected_spo["delegator_total_shares"] = 0
for delegator in spdd:
logging.info(f"SPO: {mc_pub_key}, Delegator: {delegator}")
expected_delegator = {}
stake_key_hash = delegator._mapping["stake_hash"][2:]
expected_delegator["id"] = {"StakeKeyHash": f"0x{stake_key_hash}"}
expected_delegator["share"] = int(delegator._mapping["stake_amount"])
expected_spo["delegators"].append(expected_delegator)
expected_spo["delegator_total_shares"] += int(delegator._mapping["stake_amount"])

logging.info(f"Expected SPO: {expected_spo}")

assert expected_spo in block_participation["producer_participation"]
block_participation["producer_participation"].remove(expected_spo)
all_spo_keys.add(mc_pub_key)

# Now remove all Incentivized entries from participation data that match our collected SPOs
logging.info(f"Total unique SPO candidates found: {len(all_spo_keys)}")
for mc_pub_key in all_spo_keys:
# Remove all entries for this SPO producer (there may be multiple with different block counts)
entries_to_remove = [
entry for entry in block_participation["producer_participation"]
if entry["block_producer"].get("Incentivized") and
entry["block_producer"]["Incentivized"][1] == mc_pub_key
]
for entry in entries_to_remove:
logging.info(f"Removing SPO entry: {entry}")
block_participation["producer_participation"].remove(entry)


@mark.dependency(depends=["pro_bono_participation", "spo_participation"])
Expand Down
Loading