def test_node_reg_in_ordered_from_audit_for_tree_txns(test_node):
node_regs = {}
replica = test_node.master_replica
test_node.primaries = ["Alpha", "Beta"]
node_reg = ["Alpha", "Beta", "Gamma", "Delta", "Eta"]
for i in range(3):
pp = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=i)
key = (pp.viewNo, pp.ppSeqNo)
replica._ordering_service.prePrepares[key] = pp
replica._consensus_data.preprepared.append(preprepare_to_batch_id(pp))
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pp,
state_root=pp.stateRootHash,
txn_root=pp.txnRootHash,
primaries=["Node{}".format(num) for num in range(i + 1)],
valid_digests=pp.reqIdr)
three_pc_batch.node_reg = node_reg + ["Node{}".format(i + 10)]
test_node.write_manager.audit_b_handler.post_batch_applied(
three_pc_batch)
node_regs[key] = three_pc_batch.node_reg
for key in reversed(list(node_regs.keys())):
replica._ordering_service._order_3pc_key(key)
for ordered in replica.outBox:
if not isinstance(ordered, Ordered):
continue
assert ordered.nodeReg == node_regs[(ordered.viewNo, ordered.ppSeqNo)]
def test_primaries_in_ordered_from_audit_for_tree_txns(test_node):
primaries = {}
replica = test_node.master_replica
for i in range(3):
pp = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=i)
key = (pp.viewNo, pp.ppSeqNo)
replica._ordering_service.prePrepares[key] = pp
replica._consensus_data.preprepared.append(preprepare_to_batch_id(pp))
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pp,
state_root=pp.stateRootHash,
txn_root=pp.txnRootHash,
valid_digests=pp.reqIdr)
three_pc_batch.primaries = [
"Node{}".format(num) for num in range(i + 1)
]
three_pc_batch.node_reg = ["Alpha", "Beta", "Gamma", "Delta", "Eta"]
test_node.write_manager.audit_b_handler.post_batch_applied(
three_pc_batch)
primaries[key] = three_pc_batch.primaries
for key in reversed(list(primaries.keys())):
pp = replica._ordering_service.get_preprepare(*key)
assert replica._ordering_service._get_primaries_for_ordered(
pp) == primaries[key]
def test_clear_old_view_pre_prepares_till_3pc(orderer):
orderer.old_view_preprepares[(0, 1, 'd1')] = create_pre_prepare_no_bls(generate_state_root(),
view_no=0, pp_seq_no=1)
orderer.old_view_preprepares[(0, 2, 'd2')] = create_pre_prepare_no_bls(generate_state_root(),
view_no=0, pp_seq_no=2)
orderer.old_view_preprepares[(1, 3, 'd3')] = create_pre_prepare_no_bls(generate_state_root(),
view_no=1, pp_seq_no=3)
orderer.old_view_preprepares[(1, 4, 'd4')] = create_pre_prepare_no_bls(generate_state_root(),
view_no=1, pp_seq_no=4)
orderer.old_view_preprepares[(2, 5, 'd5')] = create_pre_prepare_no_bls(generate_state_root(),
view_no=1, pp_seq_no=5)
orderer.gc(till3PCKey=(1, 3))
assert len(orderer.old_view_preprepares) == 2
assert (1, 4, 'd4') in orderer.old_view_preprepares
assert (2, 5, 'd5') in orderer.old_view_preprepares
def test_last_prepared_sertificate_return_max_3PC_key(replica):
"""
All the prepares has enough quorum. Expected result is that last_prepared_sertificate
must be Max3PCKey(all of prepare's keys) == (0, 2)
"""
replica.prepares.clear()
prepare1 = create_pre_prepare_no_bls(state_root='8J7o1k3mDX2jtBvgVfFbijdy6NKbfeJ7SfY3K1nHLzQB',
view_no=0, pp_seq_no=1)
prepare1.voters = ('Alpha:0', 'Beta:0', 'Gamma:0', 'Delta:0')
replica.prepares[(0, 1)] = prepare1
prepare2 = create_pre_prepare_no_bls(state_root='EuDgqga9DNr4bjH57Rdq6BRtvCN1PV9UX5Mpnm9gbMAZ',
view_no=0, pp_seq_no=2)
prepare2.voters = ('Alpha:0', 'Beta:0', 'Gamma:0', 'Delta:0')
replica.prepares[(0, 2)] = prepare2
assert replica.last_prepared_certificate_in_view() == (0, 2)
def test_lst_sertificate_return_max_3PC_key_of_quorumed_prepare(replica):
"""
Prepare with key (0, 2) does not have quorum of prepare.
Therefore, expected Max3PC key must be (0, 1), because of previous prepare has enough quorum
"""
replica.isMaster = True
replica.prepares.clear()
prepare1 = create_pre_prepare_no_bls(state_root='8J7o1k3mDX2jtBvgVfFbijdy6NKbfeJ7SfY3K1nHLzQB',
view_no=0, pp_seq_no=1)
prepare1.voters = ('Alpha:0', 'Beta:0', 'Gamma:0', 'Delta:0')
replica.prepares[(0, 1)] = prepare1
prepare2 = create_pre_prepare_no_bls(state_root='EuDgqga9DNr4bjH57Rdq6BRtvCN1PV9UX5Mpnm9gbMAZ',
view_no=0, pp_seq_no=2)
prepare2.voters = ('Delta:0',)
replica.prepares[(0, 2)] = prepare2
assert replica.last_prepared_certificate_in_view() == (0, 1)
def test_clear_old_view_pre_prepares_till_3pc_multiple_digests(orderer):
pp1 = create_pre_prepare_no_bls(generate_state_root(),
view_no=0,
pp_seq_no=1)
orderer.old_view_preprepares[(0, 1, 'd1')] = pp1
orderer.old_view_preprepares[(0, 1, 'd2')] = pp1
pp2 = create_pre_prepare_no_bls(generate_state_root(),
view_no=1,
pp_seq_no=2)
orderer.old_view_preprepares[(1, 2, 'd1')] = pp2
orderer.old_view_preprepares[(1, 2, 'd2')] = pp2
orderer.gc(till3PCKey=(1, 1))
assert len(orderer.old_view_preprepares) == 2
assert (1, 2, 'd1') in orderer.old_view_preprepares
assert (1, 2, 'd2') in orderer.old_view_preprepares
def create_three_pc_msgs(replica, pp_seq_no):
pre_prepare = create_pre_prepare_no_bls(generate_state_root(),
view_no=replica.viewNo,
pp_seq_no=pp_seq_no,
inst_id=replica.instId)
prepare = create_prepare(req_key=(replica.viewNo, pp_seq_no),
state_root=generate_state_root(),
inst_id=replica.instId)
commit = create_commit_no_bls_sig(req_key=(replica.viewNo, pp_seq_no),
inst_id=replica.instId)
return [pre_prepare, prepare, commit]
def create_3pc_msgs(view_no, pp_seq_no, inst_id):
pre_prepare = create_pre_prepare_no_bls(generate_state_root(),
view_no=view_no,
pp_seq_no=pp_seq_no,
inst_id=inst_id)
prepare = create_prepare(req_key=(view_no, pp_seq_no),
state_root=generate_state_root(),
inst_id=inst_id)
commit = create_commit_no_bls_sig(req_key=(view_no, pp_seq_no),
inst_id=inst_id)
return [pre_prepare, prepare, commit]
def test_check_previous_view_view_change_prep_cert_non_commit(validator, pp_seq_no):
validator.replica.node.view_change_in_progress = True
validator.replica.last_prepared_before_view_change = (validator.view_no - 1, 10)
pre_prepare = create_pre_prepare_no_bls(generate_state_root(),
view_no=validator.view_no - 1,
pp_seq_no=pp_seq_no,
inst_id=validator.inst_id)
prepare = create_prepare(req_key=(validator.view_no - 1, pp_seq_no),
state_root=generate_state_root(),
inst_id=validator.inst_id)
assert validator.validate_3pc_msg(pre_prepare) == (DISCARD, OLD_VIEW)
assert validator.validate_3pc_msg(prepare) == (DISCARD, OLD_VIEW)
def test_primaries_in_ordered_from_node(test_node):
pre_prepare = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=1)
key = (pre_prepare.viewNo, pre_prepare.ppSeqNo)
test_node.primaries = ["Alpha", "Beta"]
replica = test_node.master_replica
replica.prePrepares[key] = pre_prepare
replica.order_3pc_key(key)
ordered = replica.outBox.pop()
assert ordered.primaries == test_node.primaries
def test_check_previous_view_view_change_prep_cert_non_commit(
validator, pp_seq_no, inst_id, view_no):
validator._data.legacy_vc_in_progress = True
validator._data.view_no = view_no + 1
validator._data.legacy_last_prepared_before_view_change = (view_no, 10)
pre_prepare = create_pre_prepare_no_bls(generate_state_root(),
view_no=view_no,
pp_seq_no=pp_seq_no,
inst_id=inst_id)
prepare = create_prepare(req_key=(view_no, pp_seq_no),
state_root=generate_state_root(),
inst_id=inst_id)
assert validator.validate(pre_prepare) == (DISCARD, OLD_VIEW)
assert validator.validate(prepare) == (DISCARD, OLD_VIEW)
def test_cleanup_after_checkpoint_stabilize(orderer):
orderer._write_manager.future_primary_handler = FakeSomething(primaries={})
pre_prepares = [
create_pre_prepare_no_bls(generate_state_root(),
view_no=0,
pp_seq_no=1),
create_pre_prepare_no_bls(generate_state_root(),
view_no=1,
pp_seq_no=2),
create_pre_prepare_no_bls(generate_state_root(),
view_no=1,
pp_seq_no=3)
]
dicts_to_cleaning = [
orderer.pre_prepare_tss, orderer.sent_preprepares, orderer.prePrepares,
orderer.prepares, orderer.commits, orderer.batches,
orderer.pre_prepares_stashed_for_incorrect_time
]
lists_to_cleaning = [orderer._data.prepared, orderer._data.preprepared]
for pp in pre_prepares:
for dict_to_cleaning in dicts_to_cleaning:
dict_to_cleaning[(pp.viewNo, pp.ppSeqNo)] = pp
for list_to_cleaning in lists_to_cleaning:
list_to_cleaning.append(preprepare_to_batch_id(pp))
orderer._bus.send(CheckpointStabilized(last_stable_3pc=(1, 2)))
for pp in pre_prepares[:2]:
for dict_to_cleaning in dicts_to_cleaning:
assert (pp.viewNo, pp.ppSeqNo) not in dict_to_cleaning
for list_to_cleaning in lists_to_cleaning:
assert preprepare_to_batch_id(pp) not in list_to_cleaning
for dict_to_cleaning in dicts_to_cleaning:
assert (pre_prepares[2].viewNo,
pre_prepares[2].ppSeqNo) in dict_to_cleaning
for list_to_cleaning in lists_to_cleaning:
assert preprepare_to_batch_id(pre_prepares[2]) in list_to_cleaning
def test_process_pre_prepare_with_incorrect_pool_state_root(fake_replica):
state_roots = [
"EuDgqga9DNr4bjH57Rdq6BRtvCN1PV9UX5Mpnm9gbMAZ",
"C95JmfG5DYAE8ZcdTTFMiwcZaDN6CRVdSdkhBXnkYPio"
]
fake_replica.stateRootHash = lambda ledger, to_str=False: state_roots[
ledger]
def reportSuspiciousNodeEx(ex):
assert Suspicions.PPR_POOL_STATE_ROOT_HASH_WRONG.code == ex.code
fake_replica.node.reportSuspiciousNodeEx = reportSuspiciousNodeEx
pp = create_pre_prepare_no_bls(
state_roots[DOMAIN_LEDGER_ID], fake_replica.viewNo,
"HSai3sMHKeAva4gWMabDrm1yNhezvPHfXnGyHf2ex1L4")
fake_replica.processPrePrepare(pp, fake_replica.primaryName)
def test_check_catchup_modes_in_view_change_for_prep_cert_for_non_commit(
validator, mode, view_no, inst_id):
pp_seq_no = 10
validator._data.legacy_vc_in_progress = True
validator._data.node_mode = mode
validator._data.view_no = view_no + 1
validator._data.legacy_last_prepared_before_view_change = (view_no,
pp_seq_no)
pre_prepare = create_pre_prepare_no_bls(generate_state_root(),
view_no=view_no,
pp_seq_no=pp_seq_no,
inst_id=inst_id)
prepare = create_prepare(req_key=(view_no, pp_seq_no),
state_root=generate_state_root(),
inst_id=inst_id)
assert validator.validate(pre_prepare) == (DISCARD, OLD_VIEW)
assert validator.validate(prepare) == (DISCARD, OLD_VIEW)
def testNodeDiscardMessageFromUnknownView(
txnPoolNodeSet, sdk_node_set_with_node_added_after_some_txns,
sdk_new_node_caught_up, allPluginsPath, sdk_wallet_client):
"""
Node discards 3-phase or ViewChangeDone messages from view nos that it does not
know of (view nos before it joined the pool)
:return:
"""
looper, new_node, sdk_pool_handle, new_steward_wallet_handle = \
sdk_node_set_with_node_added_after_some_txns
viewNo = new_node.viewNo
pp_seq_no = get_pp_seq_no(txnPoolNodeSet)
# Force two view changes: node discards msgs which have viewNo
# at least two less than node's. Current protocol implementation
# needs to hold messages from the previous view as well as
# from the current view.
for i in range(1):
ensure_view_change(looper, txnPoolNodeSet)
waitNodeDataEquality(looper, new_node, *txnPoolNodeSet[:-1])
checkProtocolInstanceSetup(looper, txnPoolNodeSet, retryWait=1)
pp_seq_no += 1
sender = txnPoolNodeSet[1]
rid_x_node = sender.nodestack.getRemote(new_node.name).uid
messageTimeout = waits.expectedNodeToNodeMessageDeliveryTime()
# 3 pc msg (PrePrepare) needs to be discarded
_, did = sdk_wallet_client
primaryRepl = getPrimaryReplica(txnPoolNodeSet)
inst_id = 0
three_pc = create_pre_prepare_no_bls(
primaryRepl.node.db_manager.get_state_root_hash(DOMAIN_LEDGER_ID),
viewNo,
pp_seq_no=pp_seq_no + 1,
inst_id=inst_id)
sender.send(three_pc, rid_x_node)
looper.run(
eventually(checkDiscardMsg, [
new_node.replicas[inst_id].stasher,
],
three_pc,
OLD_VIEW,
retryWait=1,
timeout=messageTimeout))
def test_node_reg_in_ordered_from_audit(test_node):
pre_prepare = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=1)
replica = test_node.master_replica
key = (pre_prepare.viewNo, pre_prepare.ppSeqNo)
replica._ordering_service.prePrepares[key] = pre_prepare
replica._consensus_data.preprepared.append(
preprepare_to_batch_id(pre_prepare))
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pre_prepare,
state_root=pre_prepare.stateRootHash,
txn_root=pre_prepare.txnRootHash,
valid_digests=pre_prepare.reqIdr)
three_pc_batch.node_reg = ["Alpha", "Beta", "Gamma", "Delta", "Eta"]
three_pc_batch.primaries = ["Alpha", "Beta"]
test_node.write_manager.audit_b_handler.post_batch_applied(three_pc_batch)
assert replica._ordering_service._get_node_reg_for_ordered(
pre_prepare) == three_pc_batch.node_reg
def test_process_pre_prepare_with_ordered_request(fake_node):
fake_node.seqNoDB = FakeSomething(get=lambda req: (1, 1))
replica = fake_node.replicas[0]
pp = create_pre_prepare_no_bls(replica.stateRootHash(DOMAIN_LEDGER_ID))
replica.nonFinalisedReqs = lambda a: pp.reqIdr
def reportSuspiciousNodeEx(ex):
assert ex.code == Suspicions.PPR_WITH_ORDERED_REQUEST.code
replica.node.reportSuspiciousNodeEx = reportSuspiciousNodeEx
def request_propagates(reqs):
assert False, "Requested propagates for: {}".format(reqs)
replica.node.request_propagates = request_propagates
replica.processPrePrepare(pp, replica.primaryName)
assert (pp, replica.primaryName,
set(pp.reqIdr)) not in replica.prePreparesPendingFinReqs
def test_process_pre_prepare_with_not_final_request(fake_node):
fake_node.seqNoDB = FakeSomething(get=lambda req: (None, None))
replica = fake_node.replicas[0]
pp = create_pre_prepare_no_bls(replica.stateRootHash(DOMAIN_LEDGER_ID))
replica.nonFinalisedReqs = lambda a: set(pp.reqIdr)
def reportSuspiciousNodeEx(ex):
assert False, ex
replica.node.reportSuspiciousNodeEx = reportSuspiciousNodeEx
def request_propagates(reqs):
assert reqs == set(pp.reqIdr)
replica.node.request_propagates = request_propagates
replica.processPrePrepare(pp, replica.primaryName)
assert (pp, replica.primaryName,
set(pp.reqIdr)) in replica.prePreparesPendingFinReqs
def test_primaries_in_ordered_from_audit(test_node):
pre_prepare = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=1)
replica = test_node.master_replica
key = (pre_prepare.viewNo, pre_prepare.ppSeqNo)
replica.prePrepares[key] = pre_prepare
test_node.primaries = ["Alpha", "Beta"]
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pre_prepare,
state_root=pre_prepare.stateRootHash,
txn_root=pre_prepare.txnRootHash,
primaries=["Alpha", "Beta", "Gamma"],
valid_digests=pre_prepare.reqIdr)
test_node.audit_handler.post_batch_applied(three_pc_batch)
replica.order_3pc_key(key)
ordered = replica.outBox.pop()
assert ordered.primaries != test_node.primaries
assert ordered.primaries == three_pc_batch.primaries
def test_clear_data_on_view_change_started(internal_bus, orderer):
pp = create_pre_prepare_no_bls(
generate_state_root(),
view_no=0,
pp_seq_no=10,
inst_id=0,
audit_txn_root="HSai3sMHKeAva4gWMabDrm1yNhezvPHfXnGyHf2ex1L4")
prepare = create_prepare(req_key=(0, 10),
state_root=generate_state_root(),
inst_id=0)
commit = create_commit_no_bls_sig(req_key=(0, 10), inst_id=0)
key = (pp.viewNo, pp.ppSeqNo)
orderer.prePrepares[key] = pp
orderer.prepares[key] = prepare
orderer.commits[key] = commit
orderer.pre_prepare_tss[key][pp.auditTxnRootHash, "Node1"] = 1234
orderer.prePreparesPendingFinReqs.append(pp)
orderer.prePreparesPendingPrevPP[key] = pp
orderer.sent_preprepares[key] = pp
orderer.batches[key] = [
pp.ledgerId, pp.discarded, pp.ppTime,
generate_state_root(),
len(pp.reqIdr)
]
orderer.ordered.add(*key)
internal_bus.send(ViewChangeStarted(view_no=4))
assert not orderer.prePrepares
assert not orderer.prepares
assert not orderer.commits
assert not orderer.pre_prepare_tss
assert not orderer.prePreparesPendingFinReqs
assert not orderer.prePreparesPendingPrevPP
assert not orderer.sent_preprepares
assert not orderer.batches
assert not orderer.ordered
def test_signatures_cached_for_commits(bls_bft_replicas):
key1 = (0, 0)
pre_prepare1 = create_pre_prepare_no_bls(generate_state_root())
process_commits_for_key(key1, pre_prepare1, bls_bft_replicas)
for bls_bft in bls_bft_replicas:
assert len(bls_bft._signatures) == 1
assert len(bls_bft._signatures[key1]) == len(bls_bft_replicas)
pre_prepare2 = create_pre_prepare_no_bls(generate_state_root())
process_commits_for_key(key1, pre_prepare2, bls_bft_replicas)
for bls_bft in bls_bft_replicas:
assert len(bls_bft._signatures) == 1
assert len(bls_bft._signatures[key1]) == len(bls_bft_replicas)
key2 = (0, 1)
pre_prepare3 = create_pre_prepare_no_bls(generate_state_root())
process_commits_for_key(key2, pre_prepare3, bls_bft_replicas)
for bls_bft in bls_bft_replicas:
assert len(bls_bft._signatures) == 2
assert len(bls_bft._signatures[key1]) == len(bls_bft_replicas)
assert len(bls_bft._signatures[key2]) == len(bls_bft_replicas)
pre_prepare4 = create_pre_prepare_no_bls(generate_state_root())
process_commits_for_key(key2, pre_prepare4, bls_bft_replicas)
for bls_bft in bls_bft_replicas:
assert len(bls_bft._signatures) == 2
assert len(bls_bft._signatures[key1]) == len(bls_bft_replicas)
assert len(bls_bft._signatures[key2]) == len(bls_bft_replicas)
key3 = (1, 0)
pre_prepare5 = create_pre_prepare_no_bls(generate_state_root())
process_commits_for_key(key3, pre_prepare5, bls_bft_replicas)
for bls_bft in bls_bft_replicas:
assert len(bls_bft._signatures) == 3
assert len(bls_bft._signatures[key1]) == len(bls_bft_replicas)
assert len(bls_bft._signatures[key2]) == len(bls_bft_replicas)
assert len(bls_bft._signatures[key3]) == len(bls_bft_replicas)
pre_prepare6 = create_pre_prepare_no_bls(generate_state_root())
process_commits_for_key(key3, pre_prepare6, bls_bft_replicas)
for bls_bft in bls_bft_replicas:
assert len(bls_bft._signatures) == 3
assert len(bls_bft._signatures[key1]) == len(bls_bft_replicas)
assert len(bls_bft._signatures[key2]) == len(bls_bft_replicas)
assert len(bls_bft._signatures[key3]) == len(bls_bft_replicas)
def test_stores_old_pre_prepares_on_view_change_started(internal_bus, orderer):
pp1 = create_pre_prepare_no_bls(generate_state_root(),
view_no=0, pp_seq_no=1, inst_id=0)
pp2 = create_pre_prepare_no_bls(generate_state_root(),
view_no=0, pp_seq_no=2, inst_id=0)
pp3 = create_pre_prepare_no_bls(generate_state_root(),
view_no=1, pp_seq_no=3, inst_id=0)
pp4 = create_pre_prepare_no_bls(generate_state_root(),
view_no=2, pp_seq_no=4, inst_id=0)
pp5 = create_pre_prepare_no_bls(generate_state_root(),
view_no=3, pp_seq_no=5, inst_id=0)
pp6 = create_pre_prepare_no_bls(generate_state_root(),
view_no=3, pp_seq_no=6, inst_id=0)
orderer.prePrepares[(pp1.viewNo, pp1.ppSeqNo)] = pp1
orderer.prePrepares[(pp3.viewNo, pp3.ppSeqNo)] = pp3
orderer.sentPrePrepares[(pp2.viewNo, pp2.ppSeqNo)] = pp2
orderer.sentPrePrepares[(pp4.viewNo, pp4.ppSeqNo)] = pp4
assert not orderer.old_view_preprepares
internal_bus.send(ViewChangeStarted(view_no=4))
assert orderer.old_view_preprepares[(pp1.ppSeqNo, pp1.digest)] == pp1
assert orderer.old_view_preprepares[(pp2.ppSeqNo, pp2.digest)] == pp2
assert orderer.old_view_preprepares[(pp3.ppSeqNo, pp3.digest)] == pp3
assert orderer.old_view_preprepares[(pp4.ppSeqNo, pp4.digest)] == pp4
# next calls append to existing data
orderer.prePrepares[(pp5.viewNo, pp5.ppSeqNo)] = pp5
orderer.sentPrePrepares[(pp6.viewNo, pp6.ppSeqNo)] = pp6
internal_bus.send(ViewChangeStarted(view_no=4))
assert orderer.old_view_preprepares[(pp1.ppSeqNo, pp1.digest)] == pp1
assert orderer.old_view_preprepares[(pp2.ppSeqNo, pp2.digest)] == pp2
assert orderer.old_view_preprepares[(pp3.ppSeqNo, pp3.digest)] == pp3
assert orderer.old_view_preprepares[(pp4.ppSeqNo, pp4.digest)] == pp4
assert orderer.old_view_preprepares[(pp5.ppSeqNo, pp5.digest)] == pp5
assert orderer.old_view_preprepares[(pp6.ppSeqNo, pp6.digest)] == pp6
def pre_prepare(view_no, pp_seq_no, inst_id=0):
return create_pre_prepare_no_bls(generate_state_root(),
view_no=view_no,
pp_seq_no=pp_seq_no,
inst_id=inst_id)
def pp(data):
pp = create_pre_prepare_no_bls(generate_state_root(),
pp_seq_no=1,
view_no=data.view_no)
data.sent_preprepares[(pp.viewNo, pp.ppSeqNo)] = pp
return pp
def create_pre_prepares(view_no):
return [create_pre_prepare_no_bls(generate_state_root(), view_no=view_no, pp_seq_no=11),
create_pre_prepare_no_bls(generate_state_root(), view_no=view_no, pp_seq_no=12),
create_pre_prepare_no_bls(generate_state_root(), view_no=view_no, pp_seq_no=13)]
def msg(replica):
pp = create_pre_prepare_no_bls(generate_state_root(),
view_no=replica.viewNo,
pp_seq_no=replica.last_ordered_3pc[1] + 1,
inst_id=replica.instId)
return pp, replica.primaryName
