Python CTransaction.deserialize方法代码示例

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def sign_transaction(self, node, unsignedtx):
     rawtx = ToHex(unsignedtx)
     signresult = node.signrawtransaction(rawtx)
     tx = CTransaction()
     f = BytesIO(hex_str_to_bytes(signresult['hex']))
     tx.deserialize(f)
     return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def sign_transaction(self, node, unsignedtx):
     rawtx = ToHex(unsignedtx)
     signresult = node.signrawtransaction(rawtx)
     tx = CTransaction()
     f = BytesIO(unhexlify(signresult["hex"]))
     tx.deserialize(f)
     return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def sign_transaction(self, node, unsignedtx):
     rawtx = ToHex(unsignedtx)
     signresult = node.signrawtransaction(rawtx)
     tx = CTransaction()
     f = cStringIO.StringIO(unhexlify(signresult['hex']))
     tx.deserialize(f)
     return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def create_transaction(self, node, txid, to_address, amount):
     inputs = [{ "txid" : txid, "vout" : 0}]
     outputs = { to_address : amount }
     rawtx = node.createrawtransaction(inputs, outputs)
     tx = CTransaction()
     f = cStringIO.StringIO(unhexlify(rawtx))
     tx.deserialize(f)
     return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def create_transaction(self, node, txid, to_address, amount):
     inputs = [{ "txid" : txid, "vout" : 0}]
     outputs = { to_address : amount }
     rawtx = node.createrawtransaction(inputs, outputs)
     tx = CTransaction()
     f = BytesIO(hex_str_to_bytes(rawtx))
     tx.deserialize(f)
     return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def create_transaction(self, node, txid, to_address, amount):
     inputs = [{"txid": txid, "vout": 0}]
     outputs = {to_address: amount}
     rawtx = node.createrawtransaction(inputs, outputs)
     signresult = node.signrawtransaction(rawtx, None, None, "ALL|FORKID")
     tx = CTransaction()
     f = BytesIO(hex_str_to_bytes(signresult['hex']))
     tx.deserialize(f)
     return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def create_transaction(self, node, coinbase, to_address, amount):
     from_txid = node.getblock(coinbase)['tx'][0]
     inputs = [{ "txid" : from_txid, "vout" : 0}]
     outputs = { to_address : amount }
     rawtx = node.createrawtransaction(inputs, outputs)
     tx = CTransaction()
     f = cStringIO.StringIO(unhexlify(rawtx))
     tx.deserialize(f)
     tx.nVersion = 2
     return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
def submit_block_with_tx(node, tx):
    ctx = CTransaction()
    ctx.deserialize(io.BytesIO(hex_str_to_bytes(tx)))

    tip = node.getbestblockhash()
    height = node.getblockcount() + 1
    block_time = node.getblockheader(tip)["mediantime"] + 1
    block = blocktools.create_block(int(tip, 16), blocktools.create_coinbase(height), block_time)
    block.vtx.append(ctx)
    block.rehash()
    block.hashMerkleRoot = block.calc_merkle_root()
    block.solve()
    node.submitblock(bytes_to_hex_str(block.serialize(True)), '', True)
    return block

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def create_and_mine_tx_from_txids(self, txids, success = True):
     tx = CTransaction()
     for i in txids:
         txtmp = CTransaction()
         txraw = self.nodes[0].getrawtransaction(i)
         f = BytesIO(hex_str_to_bytes(txraw))
         txtmp.deserialize(f)
         for j in range(len(txtmp.vout)):
             tx.vin.append(CTxIn(COutPoint(int('0x'+i,0), j)))
     tx.vout.append(CTxOut(0, CScript()))
     tx.rehash()
     signresults = self.nodes[0].signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize_without_witness()))['hex']
     self.nodes[0].sendrawtransaction(signresults, True)
     self.nodes[0].generate(1)
     sync_blocks(self.nodes)

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
    def create_transaction(self, node, coinbase, to_address, amount, txModifier=None):
        from_txid = node.getblock(coinbase)['tx'][0]
        inputs = [{ "txid" : from_txid, "vout" : 0}]
        outputs = { to_address : amount }
        rawtx = node.createrawtransaction(inputs, outputs)
        tx = CTransaction()

        if txModifier:
            f = cStringIO.StringIO(unhexlify(rawtx))
            tx.deserialize(f)
            txModifier(tx)
            rawtx = hexlify(tx.serialize())

        signresult = node.signrawtransaction(rawtx)
        f = cStringIO.StringIO(unhexlify(signresult['hex']))
        tx.deserialize(f)
        return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
def create_transaction(node, coinbase, to_address, amount, expiry_height):
    from_txid = node.getblock(coinbase)['tx'][0]
    inputs = [{"txid": from_txid, "vout": 0}]
    outputs = {to_address: amount}
    rawtx = node.createrawtransaction(inputs, outputs)
    tx = CTransaction()

    # Set the expiry height
    f = cStringIO.StringIO(unhexlify(rawtx))
    tx.deserialize(f)
    tx.nExpiryHeight = expiry_height
    rawtx = hexlify(tx.serialize())

    signresult = node.signrawtransaction(rawtx)
    f = cStringIO.StringIO(unhexlify(signresult['hex']))
    tx.deserialize(f)
    tx.rehash()
    return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
    def _zmq_test(self):
        num_blocks = 5
        self.log.info("Generate %(n)d blocks (and %(n)d coinbase txes)" % {"n": num_blocks})
        genhashes = self.nodes[0].generate(num_blocks)
        self.sync_all()

        for x in range(num_blocks):
            # Should receive the coinbase txid.
            txid = self.hashtx.receive()

            # Should receive the coinbase raw transaction.
            hex = self.rawtx.receive()
            tx = CTransaction()
            tx.deserialize(BytesIO(hex))
            tx.calc_sha256()
            assert_equal(tx.hash, bytes_to_hex_str(txid))

            # Should receive the generated block hash.
            hash = bytes_to_hex_str(self.hashblock.receive())
            assert_equal(genhashes[x], hash)
            # The block should only have the coinbase txid.
            assert_equal([bytes_to_hex_str(txid)], self.nodes[1].getblock(hash)["tx"])

            # Should receive the generated raw block.
            block = self.rawblock.receive()
            assert_equal(genhashes[x], bytes_to_hex_str(hash256(block[:80])))

        self.log.info("Wait for tx from second node")
        payment_txid = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1.0)
        self.sync_all()

        # Should receive the broadcasted txid.
        txid = self.hashtx.receive()
        assert_equal(payment_txid, bytes_to_hex_str(txid))

        # Should receive the broadcasted raw transaction.
        hex = self.rawtx.receive()
        assert_equal(payment_txid, bytes_to_hex_str(hash256(hex)))

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
def txFromHex(hexstring):
    tx = CTransaction()
    f = cStringIO.StringIO(binascii.unhexlify(hexstring))
    tx.deserialize(f)
    return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
def txFromHex(hexstring):
    tx = CTransaction()
    f = BytesIO(hex_str_to_bytes(hexstring))
    tx.deserialize(f)
    return tx

# 需要导入模块: from test_framework.mininode import CTransaction [as 别名]
# 或者: from test_framework.mininode.CTransaction import deserialize [as 别名]
 def sign_transaction(self, node, tx):
     signresult = node.signrawtransaction(hexlify(tx.serialize()))
     tx = CTransaction()
     f = cStringIO.StringIO(unhexlify(signresult['hex']))
     tx.deserialize(f)
     return tx