Fetches transaction history.

        :rtype: ``list`` of ``str`` transaction IDs
421814
def get_transactions(self):
        
        self.transactions[:] = NetworkAPI.get_transactions(self.address)
        if self.segwit_address:
            self.transactions += NetworkAPI.get_transactions(self.segwit_address)
        return self.transactions
1255517
def transaction_id(self):
        
        if not self._transaction_id:
            self._transaction_id = random.randint(0, 10000000000 - 1)
        return self._transaction_id
597788
def get_block_transaction_hashes(self, block_header: BlockHeader) -> Iterable[Hash32]:
        
        return self._get_block_transaction_hashes(self.db, block_header)
1201786
def get_account_history(self, address, offset=None, count=None):
        
        cur = self.db.cursor()
        return namedb_get_account_history(cur, address, offset=offset, count=count)
849769
def get_transaction(cls, txid):
        

        for api_call in cls.GET_TX_MAIN:
            try:
                return api_call(txid)
            except cls.IGNORED_ERRORS:
                pass

        raise ConnectionError('All APIs are unreachable.')
960135
def _get_history_id(self, connection, agent_id, instance_id):
        '''
        
        '''
        cache_key = (agent_id, instance_id, )
        if cache_key in self._history_id_cache:
            history_id = self._history_id_cache[cache_key]
            return history_id
        else:
            command = text_helper.format_block("""
            SELECT id FROM histories WHERE agent_id = ? AND instance_id = ?
            """)
            cursor = connection.cursor()
            cursor.execute(command, (agent_id, instance_id, ))
            res = cursor.fetchall()
            if res:
                history_id = res[0][0]
                self._history_id_cache[cache_key] = history_id
                return history_id
            else:
                command = 'INSERT INTO histories VALUES (NULL, ?, ?)'
                cursor.execute(command, (agent_id, instance_id, ))
                history_id = cursor.lastrowid
                self._history_id_cache[cache_key] = history_id
                return history_id
931419
def previous_hashes(self) -> Optional[Iterable[Hash32]]:
        
        return self.get_prev_hashes(self.header.parent_hash, self.chaindb)
1125714
def _transactions(self):
        ""
        transactions = getattr(self._state, "transactions", None)
        if transactions is None:
            transactions = self._state.transactions = []
        return transactions
1143878
def sort(transactions):
    
    return transactions.sort(key=lambda x: datetime.datetime.strptime(x.split(':')[0], '%Y-%m-%d'))[:]
708462
def _get_history_next(self):
        
        if self._has_history:
            ret = self._input_history.return_history(1)
            self.string = ret
            self._curs_pos = len(ret)
1269794
def history(self):
        
        if self.changeset is None:
            raise NodeError('Unable to get changeset for this FileNode')
        return self.changeset.get_file_history(self.path)
95023
def previous(self):
        
        return self.model.state.get_entity(
            self.entity_type, self.entity_id, self._history_index - 1,
            connected=False)
1007488
def namedb_get_account_history(cur, address, offset=None, count=None):
    
    sql = 'SELECT * FROM accounts WHERE address = ? ORDER BY block_id DESC, vtxindex DESC'
    args = (address,)

    if count is not None:
        sql += ' LIMIT ?'
        args += (count,)

    if offset is not None:
        sql += ' OFFSET ?'
        args += (offset,)

    sql += ';'
    rows = namedb_query_execute(cur, sql, args)

    ret = []
    for rowdata in rows:
        tmp = {}
        tmp.update(rowdata)
        ret.append(tmp)

    return ret
1032433
def get_block_transactions(
            self,
            header: BlockHeader,
            transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
        
        return self._get_block_transactions(header.transaction_root, transaction_class)
680228
def _parse_transactions(self, response):
        
        transactions = list()

        if response:
            f = StringIO(response)
            reader = csv.DictReader(f)

            for line in reader:
                txn = {}
                txn['date'] = datetime.strptime(line['Date'], '%d/%m/%Y %H:%M:%S')
                txn['description'] = line['Description']
                txn['amount'] = float(line['Amount'].replace(',', ''))
                txn['reference'] = line['Transaction number']
                txn['sender'] = line['???transfer.fromOwner???']
                txn['recipient'] = line['???transfer.toOwner???']
                txn['currency'] = 'TSH'
                txn['comment'] = line['Transaction type']

                transactions.append(txn)

        return transactions
1258924
def fetch_withdrawals(self, limit: int) -> List[Withdrawal]:
        """"""
        return self._transactions(self._withdrawals, 'withdrawals', limit)
106891
def _get_block_transactions(
            self,
            transaction_root: Hash32,
            transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
        
        for encoded_transaction in self._get_block_transaction_data(self.db, transaction_root):
            yield rlp.decode(encoded_transaction, sedes=transaction_class)