Python Transaction.deserialize方法代码示例

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def signtransaction(self, tx, privkey=None):
     """Sign a transaction. The wallet keys will be used unless a private key is provided."""
     t = Transaction(tx)
     t.deserialize()
     if privkey:
         pubkey = bitcoin.public_key_from_private_key(privkey)
         t.sign({pubkey:privkey})
     else:
         self.wallet.sign_transaction(t, self.password)
     return t

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def gettransaction(self, txid, deserialized=False):
     """Retrieve a transaction. """
     tx = self.wallet.transactions.get(txid) if self.wallet else None
     if tx is None and self.network:
         raw = self.network.synchronous_get(('blockchain.transaction.get', [txid]))
         if raw:
             tx = Transaction(raw)
         else:
             raise BaseException("Unknown transaction")
     return tx.deserialize() if deserialized else tx

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def tx_response(self, response):
     params, result = self.parse_response(response)
     if not params:
         return
     tx_hash, tx_height = params
     assert tx_hash == hash_encode(sha256(result.decode('hex')))
     tx = Transaction(result)
     try:
         tx.deserialize()
     except Exception:
         self.print_msg("cannot deserialize transaction, skipping", tx_hash)
         return
     self.wallet.receive_tx_callback(tx_hash, tx, tx_height)
     self.requested_tx.remove((tx_hash, tx_height))
     self.print_error("received tx:", tx_hash, len(tx.raw))
     # callbacks
     self.network.trigger_callback('new_transaction', (tx,))
     if not self.requested_tx:
         self.network.trigger_callback('updated')

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
    def getrawtransaction(self, tx_hash):
        if self.wallet:
            tx = self.wallet.transactions.get(tx_hash)
            if tx:
                return tx

        raw = self.network.synchronous_get([ ('blockchain.transaction.get',[tx_hash]) ])[0]
        if raw:
            return Transaction.deserialize(raw)
        else:
            return "unknown transaction"

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
    def tx_response(self, response):
        params, result = self.parse_response(response)
        if not params:
            return
        tx_hash, tx_height = params
        assert tx_hash == hash_encode(Hash(result.decode('hex')))
        tx = Transaction(result)
        try:
            tx.deserialize()
        except Exception:
            self.print_msg("cannot deserialize transaction, skipping", tx_hash)
            return

        self.wallet.receive_tx_callback(tx_hash, tx, tx_height)
        self.requested_tx.remove((tx_hash, tx_height))
        self.print_error("received tx:", tx_hash, len(tx.raw))
        if not self.requested_tx:
            self.network.trigger_callback('updated')
            # Updated gets called too many times from other places as
            # well; if we used that signal we get the notification
            # three times
            self.network.trigger_callback("new_transaction")

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def sendrawtransaction(self, raw):
     tx = Transaction.deserialize(raw)
     return self.network.synchronous_get([('blockchain.transaction.broadcast', [str(tx)])])[0]

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def decoderawtransaction(self, raw):
     tx = Transaction.deserialize(raw)
     return {'inputs':tx.inputs, 'outputs':tx.outputs}

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def signrawtransaction(self, raw_tx, private_keys):
     tx = Transaction.deserialize(raw_tx)
     self.wallet.signrawtransaction(tx, private_keys, self.password)
     return tx

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def deserialize(self, tx):
     """Deserialize a serialized transaction"""
     t = Transaction(tx)
     return t.deserialize()

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def decoderawtransaction(self, raw):
     tx = Transaction(raw)
     return tx.deserialize()

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def signtxwithwallet(self, raw_tx):
     tx = Transaction(raw_tx)
     tx.deserialize()
     self.wallet.sign_transaction(tx, self.password)
     return tx

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]

#.........这里部分代码省略.........
                except Queue.Empty:
                    break
                new_addresses.append(addr)
            if new_addresses:
                self.subscribe_to_addresses(new_addresses)

            # request missing transactions
            for tx_hash, tx_height in missing_tx:
                if (tx_hash, tx_height) not in requested_tx:
                    self.network.send([ ('blockchain.transaction.get',[tx_hash, tx_height]) ], self.queue.put)
                    requested_tx.append( (tx_hash, tx_height) )
            missing_tx = []

            # detect if situation has changed
            if self.network.is_up_to_date() and self.queue.empty():
                if not self.wallet.is_up_to_date():
                    self.wallet.set_up_to_date(True)
                    self.was_updated = True
            else:
                if self.wallet.is_up_to_date():
                    self.wallet.set_up_to_date(False)
                    self.was_updated = True

            if self.was_updated:
                self.network.trigger_callback('updated')
                self.was_updated = False

            # 2. get a response
            try:
                r = self.queue.get(timeout=0.1)
            except Queue.Empty:
                continue

            # 3. process response
            method = r['method']
            params = r['params']
            result = r.get('result')
            error = r.get('error')
            if error:
                print_error("error", r)
                continue

            if method == 'blockchain.address.subscribe':
                addr = params[0]
                if self.wallet.get_status(self.wallet.get_history(addr)) != result:
                    if requested_histories.get(addr) is None:
                        self.network.send([('blockchain.address.get_history', [addr])], self.queue.put)
                        requested_histories[addr] = result

            elif method == 'blockchain.address.get_history':
                addr = params[0]
                print_error("receiving history", addr, result)
                if result == ['*']:
                    assert requested_histories.pop(addr) == '*'
                    self.wallet.receive_history_callback(addr, result)
                else:
                    hist = []
                    # check that txids are unique
                    txids = []
                    for item in result:
                        tx_hash = item['tx_hash']
                        if tx_hash not in txids:
                            txids.append(tx_hash)
                            hist.append( (tx_hash, item['height']) )

                    if len(hist) != len(result):
                        raise Exception("error: server sent history with non-unique txid", result)

                    # check that the status corresponds to what was announced
                    rs = requested_histories.pop(addr)
                    if self.wallet.get_status(hist) != rs:
                        raise Exception("error: status mismatch: %s"%addr)

                    # store received history
                    self.wallet.receive_history_callback(addr, hist)

                    # request transactions that we don't have
                    for tx_hash, tx_height in hist:
                        if self.wallet.transactions.get(tx_hash) is None:
                            if (tx_hash, tx_height) not in requested_tx and (tx_hash, tx_height) not in missing_tx:
                                missing_tx.append( (tx_hash, tx_height) )

            elif method == 'blockchain.transaction.get':
                tx_hash = params[0]
                tx_height = params[1]
                assert tx_hash == bitcoin.hash_encode(bitcoin.Hash(result.decode('hex')))
                tx = Transaction.deserialize(result)
                self.wallet.receive_tx_callback(tx_hash, tx, tx_height)
                self.was_updated = True
                requested_tx.remove( (tx_hash, tx_height) )
                print_error("received tx:", tx_hash, len(tx.raw))

            else:
                print_error("Error: Unknown message:" + method + ", " + repr(params) + ", " + repr(result) )

            if self.was_updated and not requested_tx:
                self.network.trigger_callback('updated')
                # Updated gets called too many times from other places as well; if we use that signal we get the notification three times
                self.network.trigger_callback("new_transaction")
                self.was_updated = False

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def signtxwithkey(self, raw_tx, sec):
     tx = Transaction.deserialize(raw_tx)
     pubkey = bitcoin.public_key_from_private_key(sec)
     tx.sign({ pubkey:sec })
     return tx

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def broadcast(self, tx):
     """Broadcast a transaction to the network. """
     t = Transaction.deserialize(tx)
     return self.network.synchronous_get([('blockchain.transaction.broadcast', [str(t)])])[0]

# 需要导入模块: from transaction import Transaction [as 别名]
# 或者: from transaction.Transaction import deserialize [as 别名]
 def decoderawtransaction(self, raw):
     tx = Transaction(raw)
     tx.deserialize()
     return {"inputs": tx.inputs, "outputs": tx.outputs}