def prepare_tx(self, key, receiver, blockstamp, amount, amount_base, message, currency): """ Prepare a simple Transaction document :param SigningKey key: the issuer of the transaction :param str receiver: the target of the transaction :param duniterpy.documents.BlockUID blockstamp: the blockstamp :param int amount: the amount sent to the receiver :param int amount_base: the amount base of the currency :param str message: the comment of the tx :param str currency: the target community :return: the transaction document :rtype: List[sakia.data.entities.Transaction] """ forged_tx = [] sources = [None]*41 while len(sources) > 40: result = self.tx_sources(int(amount), amount_base, currency, key.pubkey) sources = result[0] computed_outputs = result[1] overheads = result[2] # Fix issue #594 if len(sources) > 40: sources_value = 0 for s in sources[:39]: sources_value += s.amount * (10**s.base) sources_value, sources_base = reduce_base(sources_value, 0) chained_tx = self.prepare_tx(key, key.pubkey, blockstamp, sources_value, sources_base, "[CHAINED]", currency) forged_tx += chained_tx self._sources_processor.consume(sources) logging.debug("Inputs : {0}".format(sources)) inputs = self.tx_inputs(sources) unlocks = self.tx_unlocks(sources) outputs = self.tx_outputs(key.pubkey, receiver, computed_outputs, overheads) logging.debug("Outputs : {0}".format(outputs)) txdoc = TransactionDoc(10, currency, blockstamp, 0, [key.pubkey], inputs, unlocks, outputs, message, None) txdoc.sign([key]) self.commit_outputs_to_self(currency, key.pubkey, txdoc) time = self._blockchain_processor.time(currency) tx = Transaction(currency=currency, pubkey=key.pubkey, sha_hash=txdoc.sha_hash, written_block=0, blockstamp=blockstamp, timestamp=time, signatures=txdoc.signatures, issuers=[key.pubkey], receivers=[receiver], amount=amount, amount_base=amount_base, comment=txdoc.comment, txid=0, state=Transaction.TO_SEND, local=True, raw=txdoc.signed_raw()) forged_tx.append(tx) return forged_tx
def prepare_tx(self, key, receiver, blockstamp, amount, amount_base, message, currency): """ Prepare a simple Transaction document :param SigningKey key: the issuer of the transaction :param str receiver: the target of the transaction :param duniterpy.documents.BlockUID blockstamp: the blockstamp :param int amount: the amount sent to the receiver :param int amount_base: the amount base of the currency :param str message: the comment of the tx :param str currency: the target community :return: the transaction document :rtype: List[sakia.data.entities.Transaction] """ forged_tx = [] sources = [None]*41 while len(sources) > 40: result = self.tx_sources(int(amount), amount_base, currency, key.pubkey) sources = result[0] computed_outputs = result[1] overheads = result[2] # Fix issue #594 if len(sources) > 40: sources_value = 0 for s in sources[:39]: sources_value += s.amount * (10**s.base) sources_value, sources_base = reduce_base(sources_value, 0) chained_tx = self.prepare_tx(key, key.pubkey, blockstamp, sources_value, sources_base, "[CHAINED]", currency) forged_tx += chained_tx self._sources_processor.consume(sources) logging.debug("Inputs : {0}".format(sources)) inputs = self.tx_inputs(sources) unlocks = self.tx_unlocks(sources) outputs = self.tx_outputs(key.pubkey, receiver, computed_outputs, overheads) logging.debug("Outputs : {0}".format(outputs)) txdoc = TransactionDoc(10, currency, blockstamp, 0, [key.pubkey], inputs, unlocks, outputs, message, None) txdoc.sign([key]) self.commit_outputs_to_self(currency, key.pubkey, txdoc) time = self._blockchain_processor.time(currency) tx = Transaction(currency=currency, pubkey=key.pubkey, sha_hash=txdoc.sha_hash, written_block=0, blockstamp=blockstamp, timestamp=time, signatures=txdoc.signatures, issuers=[key.pubkey], receivers=[receiver], amount=amount, amount_base=amount_base, comment=txdoc.comment, txid=0, state=Transaction.TO_SEND, local=True, raw=txdoc.signed_raw()) forged_tx.append(tx) return forged_tx
async def initialize_transactions(self, connection, log_stream): """ Request transactions from the network to initialize data for a given pubkey :param sakia.data.entities.Connection connection: :param function log_stream: """ history_data = await self._bma_connector.get( connection.currency, bma.tx.history, req_args={'pubkey': connection.pubkey}) txid = 0 nb_tx = len(history_data["history"]["sent"]) + len( history_data["history"]["received"]) log_stream("Found {0} transactions".format(nb_tx)) transactions = [] for sent_data in history_data["history"]["sent"] + history_data[ "history"]["received"]: sent = TransactionDoc.from_bma_history(history_data["currency"], sent_data) log_stream("{0}/{1} transactions".format(txid, nb_tx)) try: tx = parse_transaction_doc(sent, connection.pubkey, sent_data["block_number"], sent_data["time"], txid) transactions.append(tx) self._repo.insert(tx) except sqlite3.IntegrityError: log_stream("Transaction already registered in database") await asyncio.sleep(0) txid += 1 return transactions
def restore_sources(self, pubkey, tx): """ Restore the sources of a cancelled tx :param sakia.entities.Transaction tx: """ txdoc = TransactionDoc.from_signed_raw(tx.raw) for offset, output in enumerate(txdoc.outputs): if output.conditions.left.pubkey == pubkey: source = Source(currency=self.currency, pubkey=pubkey, identifier=txdoc.sha_hash, type='T', noffset=offset, amount=output.amount, base=output.base) self._sources_processor.drop(source) for index, input in enumerate(txdoc.inputs): source = Source(currency=self.currency, pubkey=txdoc.issuers[0], identifier=input.origin_id, type=input.source, noffset=input.index, amount=input.amount, base=input.base) if source.pubkey == pubkey: self._sources_processor.insert(source)
def send_money(self, amount, sources, receiver, blockstamp, message): result = self.outputs_from_sources(amount, sources) inputs = result[0] computed_outputs = result[1] overheads = result[2] unlocks = [] for i, s in enumerate(sources): unlocks.append(Unlock(i, [SIGParameter(0)])) outputs = self.tx_outputs(receiver, computed_outputs, overheads) tx = Transaction(3, self.currency, blockstamp, 0, [self.key.pubkey], inputs, unlocks, outputs, message, None) tx.sign([self.key]) return tx
async def parse_transactions_history(self, connections, start, end): """ Request transactions from the network to initialize data for a given pubkey :param List[sakia.data.entities.Connection] connections: the list of connections found by tx parsing :param int start: the first block :param int end: the last block """ transfers_changed = [] new_transfers = {} for connection in connections: txid = 0 new_transfers[connection] = [] history_data = await self._bma_connector.get(self.currency, bma.tx.blocks, req_args={'pubkey': connection.pubkey, 'start': start, 'end': end}) for tx_data in history_data["history"]["sent"]: for tx in [t for t in self._transactions_processor.awaiting(self.currency)]: if self._transactions_processor.run_state_transitions(tx, tx_data["hash"], tx_data["block_number"]): transfers_changed.append(tx) self._logger.debug("New transaction validated : {0}".format(tx.sha_hash)) for tx_data in history_data["history"]["received"]: tx_doc = TransactionDoc.from_bma_history(history_data["currency"], tx_data) if not self._transactions_processor.find_by_hash(connection.pubkey, tx_doc.sha_hash) \ and SimpleTransaction.is_simple(tx_doc): tx = parse_transaction_doc(tx_doc, connection.pubkey, tx_data["block_number"], tx_data["time"], txid) if tx: new_transfers[connection].append(tx) self._transactions_processor.commit(tx) else: logging.debug("Error during transfer parsing") return transfers_changed, new_transfers
def get_transaction_document(current_block: dict, source: dict, from_pubkey: str, to_pubkey: str) -> Transaction: """ Return a Transaction document :param current_block: Current block infos :param source: Source to send :param from_pubkey: Public key of the issuer :param to_pubkey: Public key of the receiver :return: Transaction """ # list of inputs (sources) inputs = [ InputSource( amount=source["amount"], base=source["base"], source=source["type"], origin_id=source["identifier"], index=source["noffset"], ) ] # list of issuers of the inputs issuers = [from_pubkey] # list of unlocks of the inputs unlocks = [ Unlock( # inputs[index] index=0, # unlock inputs[index] if signatures[0] is from public key of issuers[0] parameters=[SIGParameter(0)], ) ] # lists of outputs outputs = [ OutputSource( amount=source["amount"], base=source["base"], condition="SIG({0})".format(to_pubkey), ) ] transaction = Transaction( version=TRANSACTION_VERSION, currency=current_block["currency"], blockstamp=BlockUID(current_block["number"], current_block["hash"]), locktime=0, issuers=issuers, inputs=inputs, unlocks=unlocks, outputs=outputs, comment="", signatures=[], ) return transaction
async def parse_dividends_history(self, connections, blocks, transactions): """ Request transactions from the network to initialize data for a given pubkey :param List[sakia.data.entities.Connection] connections: the list of connections found by tx parsing :param List[duniterpy.documents.Block] blocks: the list of transactions found by tx parsing :param List[sakia.data.entities.Transaction] transactions: the list of transactions found by tx parsing """ min_block_number = blocks[0].number max_block_number = blocks[-1].number dividends = {} for connection in connections: dividends[connection] = [] history_data = await self._bma_connector.get( self.currency, bma.ud.history, req_args={'pubkey': connection.pubkey}) block_numbers = [] for ud_data in history_data["history"]["history"]: dividend = Dividend(currency=self.currency, pubkey=connection.pubkey, block_number=ud_data["block_number"], timestamp=ud_data["time"], amount=ud_data["amount"], base=ud_data["base"]) if max_block_number >= dividend.block_number >= min_block_number: self._logger.debug("Dividend of block {0}".format( dividend.block_number)) block_numbers.append(dividend.block_number) if self._dividends_processor.commit(dividend): dividends[connection].append(dividend) for tx in transactions[connection]: txdoc = TransactionDoc.from_signed_raw(tx.raw) for input in txdoc.inputs: # For each dividends inputs, if it is consumed (not present in ud history) if input.source == "D" and input.origin_id == connection.pubkey and input.index not in block_numbers: try: # we try to get the block of the dividend block = next( (b for b in blocks if b.number == input.index)) except StopIteration: block_data = await self._bma_connector.get( self.currency, bma.blockchain.block, req_args={'number': input.index}) block = Block.from_signed_raw( block_data["raw"] + block_data["signature"] + "\n") dividend = Dividend(currency=self.currency, pubkey=connection.pubkey, block_number=input.index, timestamp=block.mediantime, amount=block.ud, base=block.unit_base) self._logger.debug("Dividend of block {0}".format( dividend.block_number)) if self._dividends_processor.commit(dividend): dividends[connection].append(dividend) return dividends
async def process(self, request): data = await request.post() if self.reject_next_post: self.reject_next_post = False return {'ucode': errors.UNHANDLED, 'message': "Rejected"}, 400 transaction = Transaction.from_signed_raw(data["transaction"]) self.forge.pool.append(transaction) return {}, 200
async def initialize_dividends(self, connection, transactions, log_stream, progress): """ Request transactions from the network to initialize data for a given pubkey :param sakia.data.entities.Connection connection: :param List[sakia.data.entities.Transaction] transactions: the list of transactions found by tx processor :param function log_stream: :param function progress: progress callback """ blockchain = self._blockchain_repo.get_one( currency=connection.currency) avg_blocks_per_month = int(30 * 24 * 3600 / blockchain.parameters.avg_gen_time) start = blockchain.current_buid.number - avg_blocks_per_month history_data = await self._bma_connector.get( connection.currency, bma.ud.history, req_args={'pubkey': connection.pubkey}) block_numbers = [] dividends = [] for ud_data in history_data["history"]["history"]: if ud_data["block_number"] > start: dividend = Dividend(currency=connection.currency, pubkey=connection.pubkey, block_number=ud_data["block_number"], timestamp=ud_data["time"], amount=ud_data["amount"], base=ud_data["base"]) log_stream("Dividend of block {0}".format( dividend.block_number)) block_numbers.append(dividend.block_number) try: dividends.append(dividend) self._repo.insert(dividend) except sqlite3.IntegrityError: log_stream("Dividend already registered in database") for tx in transactions: txdoc = Transaction.from_signed_raw(tx.raw) for input in txdoc.inputs: if input.source == "D" and input.origin_id == connection.pubkey \ and input.index not in block_numbers and input.index > start: diff_blocks = blockchain.current_buid.number - input.index ud_mediantime = blockchain.median_time - diff_blocks * blockchain.parameters.avg_gen_time dividend = Dividend(currency=connection.currency, pubkey=connection.pubkey, block_number=input.index, timestamp=ud_mediantime, amount=input.amount, base=input.base) log_stream("Dividend of block {0}".format( dividend.block_number)) try: dividends.append(dividend) self._repo.insert(dividend) except sqlite3.IntegrityError: log_stream("Dividend already registered in database") return dividends
async def initialize_dividends(self, connection, transactions, log_stream): """ Request transactions from the network to initialize data for a given pubkey :param sakia.data.entities.Connection connection: :param List[sakia.data.entities.Transaction] transactions: the list of transactions found by tx processor :param function log_stream: """ history_data = await self._bma_connector.get( connection.currency, bma.ud.history, req_args={'pubkey': connection.pubkey}) log_stream("Found {0} available dividends".format( len(history_data["history"]["history"]))) block_numbers = [] dividends = [] for ud_data in history_data["history"]["history"]: dividend = Dividend(currency=connection.currency, pubkey=connection.pubkey, block_number=ud_data["block_number"], timestamp=ud_data["time"], amount=ud_data["amount"], base=ud_data["base"]) log_stream("Dividend of block {0}".format(dividend.block_number)) block_numbers.append(dividend.block_number) try: dividends.append(dividend) self._repo.insert(dividend) except sqlite3.IntegrityError: log_stream("Dividend already registered in database") for tx in transactions: txdoc = Transaction.from_signed_raw(tx.raw) for input in txdoc.inputs: if input.source == "D" and input.origin_id == connection.pubkey and input.index not in block_numbers: block = await self._bma_connector.get( connection.currency, bma.blockchain.block, req_args={'number': input.index}) await asyncio.sleep(0.5) dividend = Dividend(currency=connection.currency, pubkey=connection.pubkey, block_number=input.index, timestamp=block["medianTime"], amount=block["dividend"], base=block["unitbase"]) log_stream("Dividend of block {0}".format( dividend.block_number)) try: dividends.append(dividend) self._repo.insert(dividend) except sqlite3.IntegrityError: log_stream("Dividend already registered in database") return dividends
def get_transaction_document(current_block, source, from_pubkey, to_pubkey): """ Return a Transaction document :param dict current_block: Current block infos :param dict source: Source to send :param str from_pubkey: Public key of the issuer :param str to_pubkey: Public key of the receiver :return: Transaction """ # list of inputs (sources) inputs = [ InputSource(amount=source['amount'], base=source['base'], source=source['type'], origin_id=source['identifier'], index=source['noffset']) ] # list of issuers of the inputs issuers = [from_pubkey] # list of unlocks of the inputs unlocks = [ Unlock( # inputs[index] index=0, # unlock inputs[index] if signatures[0] is from public key of issuers[0] parameters=[SIGParameter(0)]) ] # lists of outputs outputs = [ OutputSource( amount=source['amount'], base=source['base'], # only the receiver of the output can use it as input in another transaction conditions=Condition.token(SIG.token(to_pubkey))) ] transaction = Transaction(version=TRANSACTION_VERSION, currency=current_block['currency'], blockstamp=BlockUID(current_block['number'], current_block['hash']), locktime=0, issuers=issuers, inputs=inputs, unlocks=unlocks, outputs=outputs, comment='', signatures=None) return transaction
async def generate_transaction_document( issuers, tx_amounts, listinput_and_amount, outputAddresses, Comment="", OutputbackChange=None, ): listinput = listinput_and_amount[0] totalAmountInput = listinput_and_amount[1] total_tx_amount = sum(tx_amounts) head_block = await HeadBlock().head_block currency_name = head_block["currency"] blockstamp_current = BlockUID(head_block["number"], head_block["hash"]) curentUnitBase = head_block["unitbase"] if not OutputbackChange: OutputbackChange = issuers # if it's not a foreign exchange transaction, we remove units after 2 digits after the decimal point. if issuers not in outputAddresses: total_tx_amount = (total_tx_amount // 10**curentUnitBase) * 10**curentUnitBase # Generate output ################ listoutput = [] for tx_amount, outputAddress in zip(tx_amounts, outputAddresses): generate_output(listoutput, curentUnitBase, tx_amount, outputAddress) # Outputs to himself rest = totalAmountInput - total_tx_amount generate_output(listoutput, curentUnitBase, rest, OutputbackChange) # Unlocks unlocks = generate_unlocks(listinput) # Generate transaction document ############################## return Transaction( version=10, currency=currency_name, blockstamp=blockstamp_current, locktime=0, issuers=[issuers], inputs=listinput, unlocks=unlocks, outputs=listoutput, comment=Comment, signatures=[], )
async def initialize_dividends(self, connection, transactions, log_stream, progress): """ Request transactions from the network to initialize data for a given pubkey :param sakia.data.entities.Connection connection: :param List[sakia.data.entities.Transaction] transactions: the list of transactions found by tx processor :param function log_stream: :param function progress: progress callback """ blockchain = self._blockchain_repo.get_one(currency=connection.currency) avg_blocks_per_month = int(30 * 24 * 3600 / blockchain.parameters.avg_gen_time) start = blockchain.current_buid.number - avg_blocks_per_month history_data = await self._bma_connector.get(connection.currency, bma.ud.history, req_args={'pubkey': connection.pubkey}) block_numbers = [] dividends = [] for ud_data in history_data["history"]["history"]: if ud_data["block_number"] > start: dividend = Dividend(currency=connection.currency, pubkey=connection.pubkey, block_number=ud_data["block_number"], timestamp=ud_data["time"], amount=ud_data["amount"], base=ud_data["base"]) log_stream("Dividend of block {0}".format(dividend.block_number)) block_numbers.append(dividend.block_number) try: dividends.append(dividend) self._repo.insert(dividend) except sqlite3.IntegrityError: log_stream("Dividend already registered in database") for tx in transactions: txdoc = Transaction.from_signed_raw(tx.raw) for input in txdoc.inputs: if input.source == "D" and input.origin_id == connection.pubkey \ and input.index not in block_numbers and input.index > start: diff_blocks = blockchain.current_buid.number - input.index ud_mediantime = blockchain.median_time - diff_blocks*blockchain.parameters.avg_gen_time dividend = Dividend(currency=connection.currency, pubkey=connection.pubkey, block_number=input.index, timestamp=ud_mediantime, amount=input.amount, base=input.base) log_stream("Dividend of block {0}".format(dividend.block_number)) try: dividends.append(dividend) self._repo.insert(dividend) except sqlite3.IntegrityError: log_stream("Dividend already registered in database") return dividends
def parse_transaction_inputs(self, pubkey, transaction): """ Parse a transaction :param sakia.data.entities.Transaction transaction: """ txdoc = TransactionDoc.from_signed_raw(transaction.raw) for index, input in enumerate(txdoc.inputs): source = Source(currency=self.currency, pubkey=txdoc.issuers[0], identifier=input.origin_id, type=input.source, noffset=input.index, amount=input.amount, base=input.base) if source.pubkey == pubkey: self._sources_processor.drop(source)
def parse_transaction_outputs(self, pubkey, transaction): """ Parse a transaction :param sakia.data.entities.Transaction transaction: """ txdoc = TransactionDoc.from_signed_raw(transaction.raw) for offset, output in enumerate(txdoc.outputs): if output.conditions.left.pubkey == pubkey: source = Source(currency=self.currency, pubkey=pubkey, identifier=txdoc.sha_hash, type='T', noffset=offset, amount=output.amount, base=output.base) self._sources_processor.insert(source)
async def initialize_transactions(self, connection, log_stream, progress): """ Request transactions from the network to initialize data for a given pubkey :param sakia.data.entities.Connection connection: :param function log_stream: :param function progress: progress callback """ blockchain = self._blockchain_repo.get_one( currency=connection.currency) avg_blocks_per_month = int(30 * 24 * 3600 / blockchain.parameters.avg_gen_time) start = blockchain.current_buid.number - avg_blocks_per_month end = blockchain.current_buid.number history_data = await self._bma_connector.get(connection.currency, bma.tx.blocks, req_args={ 'pubkey': connection.pubkey, 'start': start, 'end': end }) txid = 0 nb_tx = len(history_data["history"]["sent"]) + len( history_data["history"]["received"]) log_stream("Found {0} transactions".format(nb_tx)) transactions = [] for sent_data in history_data["history"]["sent"] + history_data[ "history"]["received"]: sent = TransactionDoc.from_bma_history(history_data["currency"], sent_data) log_stream("{0}/{1} transactions".format(txid, nb_tx)) progress(1 / nb_tx) try: tx = parse_transaction_doc(sent, connection.pubkey, sent_data["block_number"], sent_data["time"], txid) if tx: transactions.append(tx) self._repo.insert(tx) else: log_stream("ERROR : Could not parse transaction") except sqlite3.IntegrityError: log_stream("Transaction already registered in database") await asyncio.sleep(0) txid += 1 return transactions
async def parse_transactions_history(self, connections, start, end): """ Request transactions from the network to initialize data for a given pubkey :param List[sakia.data.entities.Connection] connections: the list of connections found by tx parsing :param int start: the first block :param int end: the last block """ transfers_changed = [] new_transfers = {} for connection in connections: txid = 0 new_transfers[connection] = [] history_data = await self._bma_connector.get(self.currency, bma.tx.blocks, req_args={ 'pubkey': connection.pubkey, 'start': start, 'end': end }) for tx_data in history_data["history"]["sent"]: for tx in [ t for t in self._transactions_processor.awaiting( self.currency) ]: if self._transactions_processor.run_state_transitions( tx, tx_data["hash"], tx_data["block_number"]): transfers_changed.append(tx) self._logger.debug( "New transaction validated : {0}".format( tx.sha_hash)) for tx_data in history_data["history"]["received"]: tx_doc = TransactionDoc.from_bma_history( history_data["currency"], tx_data) if not self._transactions_processor.find_by_hash(connection.pubkey, tx_doc.sha_hash) \ and SimpleTransaction.is_simple(tx_doc): tx = parse_transaction_doc(tx_doc, connection.pubkey, tx_data["block_number"], tx_data["time"], txid) if tx: new_transfers[connection].append(tx) self._transactions_processor.commit(tx) else: logging.debug("Error during transfer parsing") return transfers_changed, new_transfers
async def parse_dividends_history(self, connections, start, end, transactions): """ Request transactions from the network to initialize data for a given pubkey :param List[sakia.data.entities.Connection] connections: the list of connections found by tx parsing :param List[duniterpy.documents.Block] blocks: the list of transactions found by tx parsing :param List[sakia.data.entities.Transaction] transactions: the list of transactions found by tx parsing """ dividends = {} for connection in connections: dividends[connection] = [] history_data = await self._bma_connector.get(self.currency, bma.ud.history, req_args={'pubkey': connection.pubkey}) block_numbers = [] for ud_data in history_data["history"]["history"]: dividend = Dividend(currency=self.currency, pubkey=connection.pubkey, block_number=ud_data["block_number"], timestamp=ud_data["time"], amount=ud_data["amount"], base=ud_data["base"]) if start <= dividend.block_number <= end: self._logger.debug("Dividend of block {0}".format(dividend.block_number)) block_numbers.append(dividend.block_number) if self._dividends_processor.commit(dividend): dividends[connection].append(dividend) for tx in transactions[connection]: txdoc = TransactionDoc.from_signed_raw(tx.raw) for input in txdoc.inputs: # For each dividends inputs, if it is consumed (not present in ud history) if input.source == "D" and input.origin_id == connection.pubkey and input.index not in block_numbers: block_data = await self._bma_connector.get(self.currency, bma.blockchain.block, req_args={'number': input.index}) block = Block.from_signed_raw(block_data["raw"] + block_data["signature"] + "\n") dividend = Dividend(currency=self.currency, pubkey=connection.pubkey, block_number=input.index, timestamp=block.mediantime, amount=block.ud, base=block.unit_base) self._logger.debug("Dividend of block {0}".format(dividend.block_number)) if self._dividends_processor.commit(dividend): dividends[connection].append(dividend) return dividends
async def initialize_transactions(self, connection, log_stream, progress): """ Request transactions from the network to initialize data for a given pubkey :param sakia.data.entities.Connection connection: :param function log_stream: :param function progress: progress callback """ blockchain = self._blockchain_repo.get_one(currency=connection.currency) avg_blocks_per_month = int(30 * 24 * 3600 / blockchain.parameters.avg_gen_time) start = blockchain.current_buid.number - avg_blocks_per_month end = blockchain.current_buid.number history_data = await self._bma_connector.get(connection.currency, bma.tx.blocks, req_args={'pubkey': connection.pubkey, 'start': start, 'end': end}) txid = 0 nb_tx = len(history_data["history"]["sent"]) + len(history_data["history"]["received"]) log_stream("Found {0} transactions".format(nb_tx)) transactions = [] for sent_data in history_data["history"]["sent"] + history_data["history"]["received"]: sent = TransactionDoc.from_bma_history(history_data["currency"], sent_data) log_stream("{0}/{1} transactions".format(txid, nb_tx)) progress(1 / nb_tx) try: tx = parse_transaction_doc(sent, connection.pubkey, sent_data["block_number"], sent_data["time"], txid) if tx: transactions.append(tx) self._repo.insert(tx) else: log_stream("ERROR : Could not parse transaction") except sqlite3.IntegrityError: log_stream("Transaction already registered in database") await asyncio.sleep(0) txid += 1 return transactions
def txdoc(self): """ :rtype: duniterpy.documents.Transaction """ return TransactionDoc.from_signed_raw(self.raw)
def txdoc(self): """ :rtype: duniterpy.documents.Transaction """ return TransactionDoc.from_signed_raw(self.raw)