Verify the transaction.

        Args:
            mempool:

        Returns:
            bool: True if verified. False otherwise.
420192
def Verify(self, mempool):
        
        if self.Gas.value % 100000000 != 0:
            return False
        return super(InvocationTransaction, self).Verify(mempool)
518666
def verify_false(self, expr, msg=None):
        
        try:
            self.assert_false(expr, msg)
        except AssertionError, e:
            if msg:
                m = "%s:\n%s" % (msg, str(e))
            else:
                m = str(e)
            self.verification_erorrs.append(m)
303091
def _verify(self, rj, token):
        
        keys = self.key_jar.get_jwt_verify_keys(rj.jwt)
        return rj.verify_compact(token, keys)
347930
def verify_signature(self, addr):
        
        return verify(virtualchain.address_reencode(addr), self.get_plaintext_to_sign(), self.sig)
1227361
def verify(self):
        
        with ffi.OutputString() as outmsg:
            if ffi.lib.LLVMPY_VerifyModule(self, outmsg):
                raise RuntimeError(str(outmsg))
1099645
def verify(self):
        
        self.response = self._postback().decode('ascii')
        self.clear_flag()
        self._verify_postback()
        if not self.flag:
            if self.is_transaction():
                if self.payment_status not in self.PAYMENT_STATUS_CHOICES:
                    self.set_flag("Invalid payment_status. (%s)" % self.payment_status)
                if duplicate_txn_id(self):
                    self.set_flag("Duplicate txn_id. (%s)" % self.txn_id)

        self.save()
1245795
def verify(self):
        
        for row in range(self.nrows()):
            result = self.verify_row(row)
            if result != 0:
                return result
        return 0
1074631
def verify(self, chksum):
        
        total = 0

        # Add together all bytes
        for byte in self.data:
            total += byteToInt(byte)

        # Add checksum too
        total += byteToInt(chksum)

        # Only keep low bits
        total &= 0xFF

        # Check result
        return total == 0xFF
1328569
def modify_mempool(mempool, remove=0, add=0, verbose=False):
    
    for i in range(remove):
        popped = mempool.pop()
        if verbose: print("removed:", popped)

    for i in range(add):
        new_txid = _make_txid()
        mempool.append(new_txid)
        if verbose: print("added:", new_txid)

    return mempool
619437
def _verify(self, connection, cert, errorNumber, errorDepth, returnCode):
        
        try:
            user = userForCert(self.store, cert)
        except ItemNotFound:
            log.msg("Connection attempt by {0!r}, but no user with that "
                    "e-mail address was found, cert digest was {1}"
                    .format(emailForCert(cert), cert.digest("sha512")))
            return False

        digest = cert.digest("sha512")
        if user.digest is None:
            user.digest = digest
            log.msg("First connection by {0!r}, stored digest: {1}"
                    .format(user.email, digest))
            return True
        elif user.digest == digest:
            log.msg("Successful connection by {0!r}".format(user.email))
            return True
        else:
            log.msg("Failed connection by {0!r}; cert digest was {1}, "
                    "expecting {2}".format(user.email, digest, user.digest))
            return False
1292877
def verify(self):
        

        if self._is_verified:
            return

        for proxy in self._proxies.values():
            proxy.verify()

        self._is_verified = True
335739
def is_verified(self):
        
        if self._verified is None:
            signature = self._data.get('Signature')
            if not signature:
                self._verified = False
                return self._verified

            # Decode the signature from base64
            signature = bytes(base64.b64decode(signature))

            # Get the message to sign
            sign_bytes = self._get_bytes_to_sign()
            if not sign_bytes:
                self._verified = False
                return self._verified

            if not self.certificate:
                self._verified = False
                return self._verified

            # Extract the public key
            pkey = self.certificate.get_pubkey()

            # Use the public key to verify the signature.
            pkey.verify_init()
            pkey.verify_update(sign_bytes)
            verify_result = pkey.verify_final(signature)

            self._verified = verify_result == 1

        return self._verified
871832
def verify(self, sign, *args, **kwargs):
        '''
        
        '''
        return self.verify_file(self.create_stream(sign), *args, **kwargs)
684560
def verify_transaction(signed_hextx, op_return_value):
    
    logging.info('verifying op_return value for transaction')
    op_return_hash = signed_hextx[-72:-8]
    result = (op_return_value == op_return_hash)
    if not result:
        error_message = 'There was a problem verifying the transaction'
        raise UnverifiedTransactionError(error_message)
    logging.info('verified OP_RETURN')
205317
def Verify(self):
        
        if not self.Hash.ToBytes() == GetGenesis().Hash.ToBytes():
            return False

        bc = GetBlockchain()

        if not bc.ContainsBlock(self.Index):
            return False

        if self.Index > 0:
            prev_header = GetBlockchain().GetHeader(self.PrevHash.ToBytes())

            if prev_header is None:
                return False

            if prev_header.Index + 1 != self.Index:
                return False

            if prev_header.Timestamp >= self.Timestamp:
                return False

        # this should be done to actually verify the block
        if not Helper.VerifyScripts(self):
            return False

        return True
140449
def verify_hash(self, hashed_data, compare_data):
        
        return self.security.hashing_context.verify(
            encode_string(compare_data), hashed_data)
1285723
def Verify(self, completely=False):
        
        res = super(Block, self).Verify()
        if not res:
            return False

        from neo.Blockchain import GetBlockchain, GetConsensusAddress

        # first TX has to be a miner transaction. other tx after that cant be miner tx
        if self.Transactions[0].Type != TransactionType.MinerTransaction:
            return False
        for tx in self.Transactions[1:]:
            if tx.Type == TransactionType.MinerTransaction:
                return False

        if completely:
            bc = GetBlockchain()

            if self.NextConsensus != GetConsensusAddress(bc.GetValidators(self.Transactions).ToArray()):
                return False

            for tx in self.Transactions:
                if not tx.Verify():
                    pass
            logger.error("Blocks cannot be fully validated at this moment.  please pass completely=False")
            raise NotImplementedError()
            # do this below!
            # foreach(Transaction tx in Transactions)
            # if (!tx.Verify(Transactions.Where(p = > !p.Hash.Equals(tx.Hash)))) return false;
            # Transaction tx_gen = Transactions.FirstOrDefault(p= > p.Type == TransactionType.MinerTransaction);
            # if (tx_gen?.Outputs.Sum(p = > p.Value) != CalculateNetFee(Transactions)) return false;

        return True