def verify_signed_transaction(
ledger_info,
signed_transaction_hash,
event_root_hash,
transaction_version,
signed_transaction_proof
):
transaction_info = TransactionInfo.from_proto(signed_transaction_proof.transaction_info)
ensure(
signed_transaction_hash == bytes(transaction_info.signed_transaction_hash),
"The hash of signed transaction does not match the transaction info in proof. \
Transaction hash: {}. Transaction hash provided by proof: {}.",
signed_transaction_hash,
bytes(transaction_info.signed_transaction_hash)
)
if event_root_hash is not None:
ensure(
bytes(event_root_hash) == bytes(transaction_info.event_root_hash),
"Event root hash ({}) doesn't match that in the transaction info ({}).",
bytes(event_root_hash),
bytes(transaction_info.event_root_hash)
)
verify_transaction_info(
ledger_info,
transaction_version,
transaction_info,
signed_transaction_proof.ledger_info_to_transaction_info_proof
)
def verify(cls, account_state_proof, ledger_info, version, address):
ensure(account_state_proof.version == version,
"State version ({}) is not expected ({}).",
account_state_proof.version, version)
verify_account_state(ledger_info, version, Address.hash(address),
account_state_proof.blob,
account_state_proof.proof)
def verify_get_txn_by_seq_num_resp(ledger_info, account, sequence_number,
fetch_events, signed_transaction_with_proof,
proof_of_current_sequence_number):
has_stx = len(signed_transaction_with_proof.__str__()) > 0
has_cur = len(proof_of_current_sequence_number.__str__()) > 0
if has_stx and not has_cur:
ensure(
fetch_events == signed_transaction_with_proof.HasField("events"),
"Bad GetAccountTxnBySeqNum response. Events requested: {}, events returned: {}.",
fetch_events, signed_transaction_with_proof.HasField("events"))
SignedTransactionWithProof.verify(
signed_transaction_with_proof, ledger_info,
signed_transaction_with_proof.version, account, sequence_number)
elif has_cur and not has_stx:
sequence_number_in_ledger = AccountResource.get_account_resource_or_default(
proof_of_current_sequence_number.blob).sequence_number
ensure(
sequence_number_in_ledger <= sequence_number,
"Server returned no transactions while it should. Seq num requested: {}, latest seq num in ledger: {}.",
sequence_number, sequence_number_in_ledger)
AccountStateWithProof.verify(proof_of_current_sequence_number,
ledger_info, ledger_info.version, account)
else:
bail(
"Bad GetAccountTxnBySeqNum response. txn_proof.is_none():{}, cur_seq_num_proof.is_none():{}",
has_stx, has_cur)
def verify_get_events_by_access_path_resp(
ledger_info,
req_access_path,
req_start_seq_num,
req_ascending,
req_limit,
events_with_proof,
proof_of_latest_event,
):
account_resource = AccountResource.get_account_resource_or_default(
proof_of_latest_event.blob)
AccountStateWithProof.verify(proof_of_latest_event, ledger_info,
ledger_info.version, req_access_path.address)
event_handle = account_resource.get_event_handle_by_query_path(
req_access_path.path)
expected_event_key = event_handle.key
expected_seq_nums = gen_events_resp_idxs(event_handle.count,
req_start_seq_num, req_ascending,
req_limit)
ensure(
len(expected_seq_nums) == len(events_with_proof),
"Expecting {} events, got {}.", len(expected_seq_nums),
len(events_with_proof))
zipped = zip(events_with_proof, expected_seq_nums)
for event_with_proof, seq_num in zipped:
EventWithProof.verify(event_with_proof, ledger_info,
expected_event_key, seq_num,
event_with_proof.transaction_version,
event_with_proof.event_index)
def verify(cls, event_with_proof, ledger_info, event_key, sequence_number,
transaction_version, event_index):
ensure(event_with_proof.event.key == bytes(event_key),
"Event key ({}) not expected ({}).", event_with_proof.event.key,
bytes(event_key))
ensure(event_with_proof.event.sequence_number == sequence_number,
"Sequence number ({}) not expected ({}).",
event_with_proof.event.sequence_number, sequence_number)
ensure(event_with_proof.transaction_version == transaction_version,
"Transaction version ({}) not expected ({}).",
event_with_proof.transaction_version, transaction_version)
ensure(event_with_proof.event_index == event_index,
"Event index ({}) not expected ({}).",
event_with_proof.event_index, event_index)
ce = ContractEvent.from_proto(event_with_proof.event)
verify_event(ledger_info, ce.hash(), transaction_version, event_index,
event_with_proof.proof)
def verify(
cls,
signed_transaction_with_proof,
ledger_info,
version,
sender,
sequence_number
):
stx = SignedTransaction.deserialize(signed_transaction_with_proof.signed_transaction.signed_txn)
#TODO: avoid duplicated deserialize.
ensure(
signed_transaction_with_proof.version == version,
"Version ({}) is not expected ({}).",
signed_transaction_with_proof.version,
version
)
ensure(
bytes(stx.sender) == sender,
"Sender ({}) not expected ({}).",
bytes(stx.sender),
sender
)
ensure(
stx.sequence_number == sequence_number,
"Sequence number ({}) not expected ({}).",
stx.sequence_number,
sequence_number
)
if signed_transaction_with_proof.HasField("events"):
events_root_hash = get_event_root_hash(signed_transaction_with_proof.events.events)
else:
events_root_hash = None
verify_signed_transaction(
ledger_info,
stx.hash(),
events_root_hash,
version,
signed_transaction_with_proof.proof
)