Creating a Bitcoin RawTX transaction using a private hex format key involves several steps:

1. Importing necessary libraries
2. Creating a Bitcoin RawTX transaction template
3. Generating a private key from a hex string
4. Creating a Bitcoin address from the private key
5. Getting the balance of the Bitcoin address
6. Creating a RawTX transaction with the desired inputs and outputs
7. Signing the RawTX transaction with the private key
8. Encoding the RawTX transaction as a hexadecimal string

Here is a Python script that performs these steps:

import hashlib
import ecdsa
import binascii
from bitcoin.core import CTransaction, COutPoint, CScript, CTxIn, CTxOut, CTx
from bitcoin.core import b2x, x2b, CBlock, CBlockIndex

# Import the private key as a hex string
private_key_hex = "your_private_key_hex"

# Generate a private key from the hex string
private_key = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)

# Create a Bitcoin address from the private key
public_key = private_key.get_verifying_key().to_string().hex()
bitcoin_address = "1" + hashlib.sha256(hashlib.sha256(public_key.encode()).digest()).hexdigest()[26:]

# Get the balance of the Bitcoin address
# This is a placeholder, you would need to use a real Bitcoin wallet API to get the balance
balance = 10.0

# Create a RawTX transaction template
tx = CTransaction()

# Add an input
tx.vin.append(CTxIn(COutPoint(0, 0), b'\x00' * 41))

# Add an output
tx.vout.append(CTxOut(int(balance * 100000000), CScript([bytes.fromhex(public_key)])))

# Set the transaction version and lock time
tx.nVersion = 2
tx.nLockTime = 0

# Sign the RawTX transaction with the private key
tx.vin[0].scriptSig = CScript([private_key.sign(b'\x18' + tx.serialize().rjust(128 // 8, b'\x00') + bytes.fromhex(public_key), hashlib.sha256).digest()])

# Encode the RawTX transaction as a hexadecimal string
tx_hex = b2x(tx.serialize()).decode('utf-8')

print(tx_hex)

This script generates a Bitcoin RawTX transaction with a single input, a single output, and signs it with the private key. Note that this is a very basic example and real-world transactions would require more complex handling, such as handling multiple inputs and outputs, handling multiple signatures, and checking the transaction for errors.

To create a Bitcoin RawTX transaction using a private key in Python, you’ll need to install the pycryptodome and bech32 libraries. You can install them using pip:

pip install pycryptodome bech32

Next, you can use the following Python script as a starting point. This script creates a raw transaction that sends all available funds from the specified address to another address. Make sure to replace the priv_key_hex, to_address, utxo_txid, utxo_vout, and fee values with your own data.

import binascii
import hashlib
from bitcoin.wallet import P2PKHBitcoinAddress
from bitcoin.core import x, b2lx, lx, COIN, CTransaction, CTxIn, CTxOut, CTxInWitness, Hash160
from bitcoin.core.script import CScript, OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG
from bitcoin.core.scripteval import VerifyScript, SCRIPT_VERIFY_P2SH
from bech32 import bech32_decode, bech32_encode

# Private key in hex format
priv_key_hex = 'your_private_key_here'

# Address to send funds to
to_address = 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq'

# Unspent transaction output (UTXO)
utxo_txid = 'your_utxo_txid_here'
utxo_vout = 0

# Fee per byte
fee = 10

# Decode the private key
priv_key_bytes = binascii.unhexlify(priv_key_hex)

# Create a P2PKH address from the private key
addr = P2PKHBitcoinAddress.from_privkey(priv_key_bytes)

# Encode the address as a bech32 string
from_address = bech32_encode('bc', Hash160(addr.to_bytes()))

# Get the UTXO amount
# Replace with your own code to get the UTXO amount
utxo_amount = 100000 # in satoshis

# Calculate the output amount (UTXO amount minus fee)
output_amount = utxo_amount - (fee * 10)

# Create a P2PKH output script
p2pkh_script = CScript([OP_DUP, OP_HASH160, Hash160(addr.to_bytes()), OP_EQUALVERIFY, OP_CHECKSIG])

# Create a P2WPKH output script
p2wpkh_script = CScript([OP_0, hashlib.sha256(P2PKHBitcoinAddress.from_pubkey(addr.pub).to_bytes()).digest()])

# Create a witness script
witness_script = CScript([addr.pub.to_bytes(), lx(int.from_bytes(priv_key_bytes, 'big'))])

# Create the transaction input
txin = CTxIn(COIN, b2lx(utxo_txid), utxo_vout)

# Create the transaction output
txout = CTxOut(output_amount, p2pkh_script)

# Create the witness
witness = CTxInWitness([witness_script.to_bytes()])

# Add the witness to the transaction input
txin.witness = witness

# Create the transaction
tx = CTransaction([txin], [txout])

# Sign the transaction
sig = priv_key_bytes.sign_digest(x(tx.hash_for_sign(0, witness.serialize(), hashlib.sha256, False)), hasher=hashlib.sha256)

# Add the signature to the witness
witness.scriptWitness.stack.append(sig)

# Set the sequence number
txin.nSequence = 0

# Serialize the transaction
raw_tx = tx.serialize()

print(raw_tx.hex())