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 )