def main():
# always remember to setup the network
setup('testnet')
priv1 = PrivateKey("cN1XE3ESGgdvr4fWsB7L3BcqXncUauF8Fo8zzv4Sm6WrkiGrsxrG")
priv2 = PrivateKey("cR8AkcbL2pgBswrHp28AftEznHPPLA86HiTog8MpNCibxwrsUcZ4")
p2wsh_witness_script = Script([
'OP_1',
priv1.get_public_key().to_hex(),
priv2.get_public_key().to_hex(), 'OP_2', 'OP_CHECKMULTISIG'
])
fromAddress = P2wshAddress.from_script(p2wsh_witness_script)
toAddress = P2wpkhAddress.from_address(
"tltc1qedur7y052upuzd7wzh60d2f86szgpuspmml8ce")
# set values
txid = '2042195c40a92353f2ffe30cd0df8d177698560e81807e8bf9174a9c0e98e6c2'
vout = 0
amount = to_satoshis(0.01)
# create transaction input from tx id of UTXO
txin = TxInput(txid, vout)
txOut1 = TxOutput(to_satoshis(0.0001), toAddress.to_script_pub_key())
txOut2 = TxOutput(to_satoshis(0.0098), fromAddress.to_script_pub_key())
tx = Transaction([txin], [txOut1, txOut2], has_segwit=True)
sig1 = priv1.sign_segwit_input(tx, 0, p2wsh_witness_script, amount)
tx.witnesses.append(Script(['OP_0', sig1, p2wsh_witness_script.to_hex()]))
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + tx.serialize())
print("\nTxId:", tx.get_txid())
def setUp(self):
setup('testnet')
# values for testing create non std tx
self.txin = TxInput(
"e2d08a63a540000222d6a92440436375d8b1bc89a2638dc5366833804287c83f",
1)
self.to_addr = P2pkhAddress('msXP94TBncQ9usP6oZNpGweE24biWjJs2d')
self.sk = PrivateKey(
'cMahea7zqjxrtgAbB7LSGbcQUr1uX1ojuat9jZodMN87JcbXMTcA')
self.txout = TxOutput(to_satoshis(0.9),
Script(['OP_ADD', 'OP_5', 'OP_EQUAL']))
self.change_addr = P2pkhAddress('mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r')
self.change_txout = TxOutput(to_satoshis(2),
self.change_addr.to_script_pub_key())
self.create_non_std_tx_result = '02000000013fc8874280336836c58d63a289bcb1d87563434024a9d622020040a5638ad0e2010000006a47304402201febc032331342baaece4b88c7ab42d7148c586b9a48944cbebde95636ac7424022018f0911a4ba664ac8cc21457a58e3a1214ba92b84cb60e57f4119fe655b3a78901210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798ffffffff02804a5d05000000000393558700c2eb0b000000001976a914751e76e8199196d454941c45d1b3a323f1433bd688ac00000000'
# values for testing create non std tx
self.txin_spend = TxInput(
"4d9a6baf45d4b57c875fe83d5e0834568eae4b5ef6e61d13720ef6685168e663",
0)
self.txin_spend.script_sig = Script(['OP_2', 'OP_3'])
self.txout_spend = TxOutput(to_satoshis(0.8),
self.change_addr.to_script_pub_key())
self.spend_non_std_tx_result = '020000000163e6685168f60e72131de6f65e4bae8e5634085e3de85f877cb5d445af6b9a4d00000000025253ffffffff0100b4c404000000001976a914751e76e8199196d454941c45d1b3a323f1433bd688ac00000000'
def main():
# always remember to setup the network
setup('testnet')
# send 2 P2PKH inputs to 1 P2WPKH output
# create transaction inputs from tx ids of UTXOs (contained 0.002 tBTC)
txin = TxInput('eddfaa3d5a1c9a2a2961638aa4e28871b09ed9620f9077482248f368d46d8205', 1)
txin2 = TxInput('cf4b2987c06b9dd2ba6770af31a4942a4ea3e7194c0d64e8699e9fda03f50551', 1)
# create transaction output using P2WPKH scriptPubKey (locking script)
addr = P2wpkhAddress('tltc1qedur7y052upuzd7wzh60d2f86szgpuspmml8ce')
txout = TxOutput(to_satoshis(0.0019), addr.to_script_pub_key())
#txout = TxOutput(to_satoshis(0.0019), Script([0, addr.to_hash()]) )
# create transaction from inputs/outputs -- default locktime is used
# note that this is not a segwit transaction since we don't spend segwit
tx = Transaction([txin, txin2], [txout]) #, has_segwit=True)
# print raw transaction
print("\nRaw unsigned transaction:\n" + tx.serialize())
# use the private keys corresponding to the address that contains the
# UTXOs we are trying to spend to sign the input
sk = PrivateKey('cTALNpTpRbbxTCJ2A5Vq88UxT44w1PE2cYqiB3n4hRvzyCev1Wwo')
sk2 = PrivateKey('cVf3kGh6552jU2rLaKwXTKq5APHPoZqCP4GQzQirWGHFoHQ9rEVt')
# note that we pass the scriptPubkey as one of the inputs of sign_input
# because it is used to replace the scriptSig of the UTXO we are trying to
# spend when creating the transaction digest
from_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
sig = sk.sign_input( tx, 0, Script(['OP_DUP', 'OP_HASH160',
from_addr.to_hash160(), 'OP_EQUALVERIFY',
'OP_CHECKSIG']) )
from_addr2 = P2pkhAddress('mmYNBho9BWQB2dSniP1NJvnPoj5EVWw89w')
sig2 = sk2.sign_input( tx, 1, from_addr2.to_script_pub_key() )
# get public key as hex
pk = sk.get_public_key().to_hex()
pk2 = sk2.get_public_key().to_hex()
# set the scriptSig (unlocking script)
txin.script_sig = Script([sig, pk])
txin2.script_sig = Script([sig2, pk2])
signed_tx = tx.serialize()
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + signed_tx)
def test_spend_p2sh_csv_p2pkh(self):
redeem_script = Script([
self.seq.for_script(), 'OP_CHECKSEQUENCEVERIFY', 'OP_DROP',
'OP_DUP', 'OP_HASH160',
self.sk_csv_p2pkh.get_public_key().to_hash160(), 'OP_EQUALVERIFY',
'OP_CHECKSIG'
])
txout = TxOutput(to_satoshis(11),
self.another_addr.to_script_pub_key())
tx = Transaction([self.txin_seq], [txout])
sig = self.sk_csv_p2pkh.sign_input(tx, 0, redeem_script)
self.txin_seq.script_sig = Script([
sig,
self.sk_csv_p2pkh.get_public_key().to_hex(),
redeem_script.to_hex()
])
self.assertEqual(tx.serialize(), self.spend_p2sh_csv_p2pkh_result)
def main():
# always remember to setup the network
setup('testnet')
# the key that corresponds to the P2WPKH address
priv = PrivateKey("cVdte9ei2xsVjmZSPtyucG43YZgNkmKTqhwiUA8M4Fc3LdPJxPmZ")
pub = priv.get_public_key()
fromAddress = pub.get_segwit_address()
print(fromAddress.to_string())
# amount is needed to sign the segwit input
fromAddressAmount = to_satoshis(0.01)
# UTXO of fromAddress
txid = '13d2d30eca974e8fa5da11b9608fa36905a22215e8df895e767fc903889367ff'
vout = 0
toAddress = P2pkhAddress('mrrKUpJnAjvQntPgz2Z4kkyr1gbtHmQv28')
# create transaction input from tx id of UTXO
txin = TxInput(txid, vout)
# the script code required for signing for p2wpkh is the same as p2pkh
script_code = Script([
'OP_DUP', 'OP_HASH160',
pub.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
])
# create transaction output
txOut = TxOutput(to_satoshis(0.009), toAddress.to_script_pub_key())
# create transaction without change output - if at least a single input is
# segwit we need to set has_segwit=True
tx = Transaction([txin], [txOut], has_segwit=True)
print("\nRaw transaction:\n" + tx.serialize())
sig = priv.sign_segwit_input(tx, 0, script_code, fromAddressAmount)
tx.witnesses.append(Script([sig, pub.to_hex()]))
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + tx.serialize())
print("\nTxId:", tx.get_txid())
def main():
# always remember to setup the network
setup('testnet')
# the key that corresponds to the P2WPKH address
priv = PrivateKey('cNho8fw3bPfLKT4jPzpANTsxTsP8aTdVBD6cXksBEXt4KhBN7uVk')
pub = priv.get_public_key()
# the p2sh script and the corresponding address
redeem_script = pub.get_segwit_address().to_script_pub_key()
p2sh_addr = P2shAddress.from_script(redeem_script)
# the UTXO of the P2SH-P2WPKH that we are trying to spend
inp = TxInput('95c5cac558a8b47436a3306ba300c8d7af4cd1d1523d35da3874153c66d99b09', 0)
# exact amount of UTXO we try to spent
amount = 0.0014
# the address to send funds to
to_addr = P2pkhAddress('mvBGdiYC8jLumpJ142ghePYuY8kecQgeqS')
# the output sending 0.001 -- 0.0004 goes to miners as fee -- no change
out = TxOutput(to_satoshis(0.001), to_addr.to_script_pub_key())
# create a tx with at least one segwit input
tx = Transaction([inp], [out], has_segwit=True)
# script code is the script that is evaluated for a witness program type; each
# witness program type has a specific template for the script code
# script code that corresponds to P2WPKH (it is the classic P2PKH)
script_code = pub.get_address().to_script_pub_key()
# calculate signature using the appropriate script code
# remember to include the original amount of the UTXO
sig = priv.sign_segwit_input(tx, 0, script_code, to_satoshis(amount))
# script_sig is the redeem script passed as a single element
inp.script_sig = Script([redeem_script.to_hex()])
# finally, the unlocking script is added as a witness
tx.witnesses.append(Script([sig, pub.to_hex()]))
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + tx.serialize())
def main():
# always remember to setup the network
setup('testnet')
#
# This script spends from a P2SH address containing a P2PK script
#
# create transaction input from tx id of UTXO (contained 0.1 tBTC)
txin = TxInput(
'7db363d5a7fabb64ccce154e906588f1936f34481223ea8c1f2c935b0a0c945b', 0)
# secret key needed to spend P2PK that is wrapped by P2SH
p2pk_sk = PrivateKey(
'cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9')
p2pk_pk = p2pk_sk.get_public_key().to_hex()
# create the redeem script - needed to sign the transaction
redeem_script = Script([p2pk_pk, 'OP_CHECKSIG'])
to_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
txout = TxOutput(to_satoshis(0.09), to_addr.to_script_pub_key())
# no change address - the remaining 0.01 tBTC will go to miners)
# create transaction from inputs/outputs -- default locktime is used
tx = Transaction([txin], [txout])
# print raw transaction
print("\nRaw unsigned transaction:\n" + tx.serialize())
# use the private key corresponding to the address that contains the
# UTXO we are trying to spend to create the signature for the txin -
# note that the redeem script is passed to replace the scriptSig
sig = p2pk_sk.sign_input(tx, 0, redeem_script)
#print(sig)
# set the scriptSig (unlocking script)
txin.script_sig = Script([sig, redeem_script.to_hex()])
signed_tx = tx.serialize()
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + signed_tx)
print("\nTxId:", tx.get_txid())
def get_issue_tx_info(conf, op_return_bstring, interactive=False):
# load apropriate blockchain libraries
if (conf.blockchain == 'litecoin'):
from litecoinutils.setup import setup
from litecoinutils.proxy import NodeProxy
from litecoinutils.transactions import Transaction, TxInput, TxOutput
from litecoinutils.keys import P2pkhAddress, P2wpkhAddress
from litecoinutils.script import Script
from litecoinutils.utils import to_satoshis, is_address_bech32
else:
from bitcoinutils.setup import setup
from bitcoinutils.proxy import NodeProxy
from bitcoinutils.transactions import Transaction, TxInput, TxOutput
from bitcoinutils.keys import P2pkhAddress, P2wpkhAddress
from bitcoinutils.script import Script
from bitcoinutils.utils import to_satoshis, is_address_bech32
op_return_hex = binascii.hexlify(op_return_bstring).decode()
if interactive:
print('\nConfigured values are:\n')
print('working_directory:\t{}'.format(conf.working_directory))
print('issuing_address:\t{}'.format(conf.issuing_address))
print('blockchain:\t\t{}'.format(conf.blockchain))
print('full_node_url:\t\t{}'.format(conf.full_node_url))
print('full_node_rpc_user:\t{}'.format(conf.full_node_rpc_user))
print('testnet:\t\t{}'.format(conf.testnet))
print('tx_fee_per_byte:\t{}'.format(conf.tx_fee_per_byte))
print('Bytes for OP_RETURN:\n{}'.format(op_return_bstring))
print('Hex for OP_RETURN:\n{}'.format(op_return_hex))
op_return_cert_protocol = op_return_hex
if interactive:
consent = input('Do you want to continue? [y/N]: ').lower() in ('y',
'yes')
if not consent:
sys.exit()
#import time
#start = time.time()
# test explicitly when non interactive
if not conf.full_node_rpc_password and interactive:
conf.full_node_rpc_password = getpass.getpass(
'\nPlease enter the password for the node\'s RPC user: '******'testnet')
else:
setup('mainnet')
host, port = conf.full_node_url.split(
':') # TODO: update when NodeProxy accepts full url!
proxy = NodeProxy(conf.full_node_rpc_user, conf.full_node_rpc_password,
host, port).get_proxy()
# checks if address is native segwit or not.
is_addr_bech32 = is_address_bech32(conf.issuing_address)
# create transaction
tx_outputs = []
unspent = sorted(proxy.listunspent(1, 9999999, [conf.issuing_address]),
key=lambda x: x['amount'],
reverse=False)
if not unspent:
raise ValueError("No UTXOs found")
issuing_pubkey = proxy.getaddressinfo(conf.issuing_address)['pubkey']
tx = None
tx_inputs = []
tx_input_data = {}
inputs_amount = 0
# coin selection: use smallest UTXO and if not enough satoshis add next
# smallest, etc. until sufficient tx fees are accumulated
# TODO wrt dust instead of adding another UTXO we should just remove the
# change_output and allocate the remaining (<546sats) to fees
for utxo in unspent:
txin = TxInput(utxo['txid'], utxo['vout'])
tx_input_data[utxo['txid']] = utxo['amount']
tx_inputs.append(txin)
inputs_amount += utxo['amount']
# currently bitcoin lib requires explicit instantiation; made method to
# check this; update if/when the library fixes/automates this
change_script_out = None
if is_addr_bech32:
change_script_out = P2wpkhAddress(
conf.issuing_address).to_script_pub_key()
else:
change_script_out = P2pkhAddress(
conf.issuing_address).to_script_pub_key()
change_output = TxOutput(to_satoshis(inputs_amount), change_script_out)
op_return_output = TxOutput(
to_satoshis(0), Script(['OP_RETURN', op_return_cert_protocol]))
tx_outputs = [change_output, op_return_output]
tx = Transaction(tx_inputs, tx_outputs, has_segwit=is_addr_bech32)
# sign transaction to get its size
r = proxy.signrawtransactionwithwallet(tx.serialize())
if r['complete'] == None:
if interactive:
sys.exit("Transaction couldn't be signed by node")
else:
raise RuntimeError("Transaction couldn't be signed by node")
signed_tx = r['hex']
signed_tx_size = proxy.decoderawtransaction(signed_tx)['vsize']
# calculate fees and change in satoshis
tx_fee = signed_tx_size * conf.tx_fee_per_byte
change_amount = to_satoshis(inputs_amount) - tx_fee
# the default Bitcoin (and litecoin) Core node doesn't allow the creation of dust
# UTXOs https://bitcoin.stackexchange.com/questions/10986/what-is-meant-by-bitcoin-dust
# if change is less than 546 (2940 for litecoin) satoshis that is considered dust
# (with the default node parameters) then include another UTXO
if conf.blockchain == 'litecoin':
if change_amount >= 3000:
break
else:
if change_amount >= 550:
break
if (change_amount < 0):
if interactive:
sys.exit(
"Specified address cannot cover the transaction fee of: {} satoshis"
.format(tx_fee))
else:
raise RuntimeError(
"insufficient satoshis, cannot create transaction")
# update tx out for change and re-sign
tx.outputs[0].amount = change_amount
return tx.serialize(), conf.issuing_address, tx_input_data
def main():
# always remember to setup the network
setup('testnet')
# create transaction input from tx id of UTXO (contained 0.39 tBTC)
# 0.1 tBTC
txin = TxInput(
'76464c2b9e2af4d63ef38a77964b3b77e629dddefc5cb9eb1a3645b1608b790f', 0)
# 0.29 tBTC
txin2 = TxInput(
'76464c2b9e2af4d63ef38a77964b3b77e629dddefc5cb9eb1a3645b1608b790f', 1)
# create transaction output using P2PKH scriptPubKey (locking script)
addr = P2pkhAddress('myPAE9HwPeKHh8FjKwBNBaHnemApo3dw6e')
txout = TxOutput(
to_satoshis(0.3),
Script([
'OP_DUP', 'OP_HASH160',
addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
]))
# create another output to get the change - remaining 0.01 is tx fees
change_addr = P2pkhAddress('mmYNBho9BWQB2dSniP1NJvnPoj5EVWw89w')
change_txout = TxOutput(
to_satoshis(0.08),
Script([
'OP_DUP', 'OP_HASH160',
change_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
]))
# create transaction from inputs/outputs -- default locktime is used
tx = Transaction([txin, txin2], [txout, change_txout])
# print raw transaction
print("\nRaw unsigned transaction:\n" + tx.serialize())
#
# use the private keys corresponding to the addresses that contains the
# UTXOs we are trying to spend to create the signatures
#
sk = PrivateKey('cTALNpTpRbbxTCJ2A5Vq88UxT44w1PE2cYqiB3n4hRvzyCev1Wwo')
sk2 = PrivateKey('cVf3kGh6552jU2rLaKwXTKq5APHPoZqCP4GQzQirWGHFoHQ9rEVt')
# we could have derived the addresses from the secret keys
from_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
from_addr2 = P2pkhAddress('mmYNBho9BWQB2dSniP1NJvnPoj5EVWw89w')
# sign the first input
sig = sk.sign_input(
tx, 0,
Script([
'OP_DUP', 'OP_HASH160',
from_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
]), SIGHASH_ALL | SIGHASH_ANYONECANPAY)
#print(sig)
# sign the second input
sig2 = sk2.sign_input(
tx, 1,
Script([
'OP_DUP', 'OP_HASH160',
from_addr2.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
]), SIGHASH_SINGLE | SIGHASH_ANYONECANPAY)
#print(sig2)
# get public key as hex
pk = sk.get_public_key()
pk = pk.to_hex()
#print (pk)
# get public key as hex
pk2 = sk2.get_public_key()
pk2 = pk2.to_hex()
# set the scriptSig (unlocking script)
txin.script_sig = Script([sig, pk])
txin2.script_sig = Script([sig2, pk2])
signed_tx = tx.serialize()
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + signed_tx)
print("\nTxId:", tx.get_txid())
def test_non_segwit():
# always remember to setup the network
setup('testnet')
# create transaction input from tx id of UTXO (contained 0.4 tBTC)
txin = TxInput(
'fb48f4e23bf6ddf606714141ac78c3e921c8c0bebeb7c8abb2c799e9ff96ce6c', 0)
# create transaction output using P2PKH scriptPubKey (locking script)
addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
txout = TxOutput(
to_satoshis(0.1),
Script([
'OP_DUP', 'OP_HASH160',
addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
]))
# create another output to get the change - remaining 0.01 is tx fees
# note that this time we used to_script_pub_key() to create the P2PKH
# script
change_addr = P2pkhAddress('mmYNBho9BWQB2dSniP1NJvnPoj5EVWw89w')
change_txout = TxOutput(to_satoshis(0.29), change_addr.to_script_pub_key())
#change_txout = TxOutput(to_satoshis(0.29), Script(['OP_DUP', 'OP_HASH160',
# change_addr.to_hash160(),
# 'OP_EQUALVERIFY', 'OP_CHECKSIG']))
# create transaction from inputs/outputs -- default locktime is used
tx = Transaction([txin], [txout, change_txout])
print("\nUnsigned transaction:", tx)
# print raw transaction
print("\nRaw unsigned transaction:\n" + tx.serialize())
tx_from_raw = Transaction.from_raw(tx.serialize())
print("\nUnsigned from raw transaction:", tx_from_raw)
print("\nUnsigned from raw transaction raw:", tx_from_raw.serialize())
if tx_from_raw.serialize() == tx.serialize():
print("SUCCESS from_raw Serialization OK")
else:
print("ERROR from_raw Serialization failed")
if str(tx) == str(tx_from_raw):
print("SUCCESS from_raw OK")
else:
print("ERROR from_raw failed")
# use the private key corresponding to the address that contains the
# UTXO we are trying to spend to sign the input
sk = PrivateKey('cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9')
# note that we pass the scriptPubkey as one of the inputs of sign_input
# because it is used to replace the scriptSig of the UTXO we are trying to
# spend when creating the transaction digest
from_addr = P2pkhAddress('myPAE9HwPeKHh8FjKwBNBaHnemApo3dw6e')
sig = sk.sign_input(
tx, 0,
Script([
'OP_DUP', 'OP_HASH160',
from_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
]))
#print(sig)
# get public key as hex
pk = sk.get_public_key().to_hex()
# set the scriptSig (unlocking script)
txin.script_sig = Script([sig, pk])
signed_tx = tx.serialize()
print("\nSigned transaction:", tx)
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:", signed_tx)
tx_from_raw = Transaction.from_raw(tx.serialize())
print("\nSigned from raw transaction:", tx_from_raw)
print("\nSigned from raw transaction raw:", tx_from_raw.serialize())
if tx_from_raw.serialize() == tx.serialize():
print("SUCCESS signed from_raw Serialization OK")
else:
print("ERROR signed from_raw Serialization failed")
if str(tx) == str(tx_from_raw):
print("SUCCESS signed from_raw OK")
else:
print("ERROR signed from_raw failed")
def setUp(self):
setup('testnet')
self.sk = PrivateKey.from_wif(
"cTALNpTpRbbxTCJ2A5Vq88UxT44w1PE2cYqiB3n4hRvzyCev1Wwo")
# n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR
self.p2pkh_addr = self.sk.get_public_key().get_address()
# tb1ql5eh45als8sgdkt2drsl344q55g03sj2krzqe3
self.p2wpkh_addr = self.sk.get_public_key().get_segwit_address()
# P2PKH to P2WPKH
self.txin1 = TxInput(
"5a7b3aaa66d6b7b7abcdc9f1d05db4eee94a700297a319e19454e143875e1078",
0)
self.txout1 = TxOutput(to_satoshis(0.0099),
self.p2wpkh_addr.to_script_pub_key())
# P2WPKH to P2PKH
self.txin_spend = TxInput(
"b3ca1c4cc778380d1e5376a5517445104e46e97176e40741508a3b07a6483ad3",
0)
self.txin_spend_amount = to_satoshis(0.0099)
self.txout2 = TxOutput(to_satoshis(0.0098),
self.p2pkh_addr.to_script_pub_key())
self.p2pkh_redeem_script = Script([
'OP_DUP', 'OP_HASH160',
self.p2pkh_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
])
# P2WPKH P2PKH to P2PKH
self.txin_spend_p2pkh = TxInput(
"1e2a5279c868d61fb2ff0b1c2b04aa3eff02cd74952a8b4e799532635a9132cc",
0)
self.txin_spend_p2pkh_amount = to_satoshis(0.01)
self.txin_spend_p2wpkh = TxInput(
"fff39047310fbf04bdd0e0bc75dde4267ae4d25219d8ad95e0ca1cee907a60da",
0)
self.txin_spend_p2wpkh_amount = to_satoshis(0.0095)
self.txout3 = TxOutput(to_satoshis(0.0194),
self.p2pkh_addr.to_script_pub_key())
# SIGHASH NONE type send
self.txin1_signone = TxInput(
"fb4c338a00a75d73f9a6bd203ed4bd8884edeb111fac25a7946d5df6562f1942",
0)
self.txin1_signone_amount = to_satoshis(0.01)
self.txout1_signone = TxOutput(to_satoshis(0.0080),
self.p2pkh_addr.to_script_pub_key())
self.txout2_signone = TxOutput(to_satoshis(0.0019),
self.p2pkh_addr.to_script_pub_key())
# SIGHASH SINGLE type send
self.txin1_sigsingle = TxInput(
"b04909d4b5239a56d676c1d9d722f325a86878c9aa535915aa0df97df47cedeb",
0)
self.txin1_sigsingle_amount = to_satoshis(0.0193)
self.txout1_sigsingle = TxOutput(to_satoshis(0.01),
self.p2pkh_addr.to_script_pub_key())
self.txout2_sigsingle = TxOutput(to_satoshis(0.0092),
self.p2pkh_addr.to_script_pub_key())
# SIGHASH_ALL | SIGHASH_ANYONECANPAY type send
self.txin1_siganyonecanpay_all = TxInput(
"f67e97a2564dceed405e214843e3c954b47dd4f8b26ea48f82382f51f7626036",
0)
self.txin1_siganyonecanpay_all_amount = to_satoshis(0.0018)
self.txin2_siganyonecanpay_all = TxInput(
"f4afddb77cd11a79bed059463085382c50d60c7f9e4075d8469cfe60040f68eb",
0)
self.txin2_siganyonecanpay_all_amount = to_satoshis(0.0018)
self.txout1_siganyonecanpay_all = TxOutput(
to_satoshis(0.0018), self.p2pkh_addr.to_script_pub_key())
self.txout2_siganyonecanpay_all = TxOutput(
to_satoshis(0.0017), self.p2pkh_addr.to_script_pub_key())
# SIGHASH_NONE | SIGHASH_ANYONECANPAY type send
self.txin1_siganyonecanpay_none = TxInput(
"d2ae5d4a3f390f108769139c9b5757846be6693b785c4e21eab777eec7289095",
0)
self.txin1_siganyonecanpay_none_amount = to_satoshis(0.009)
self.txin2_siganyonecanpay_none = TxInput(
"ee5062d426677372e6de96e2eb47d572af5deaaef3ef225f3179dfa1ece3f4f5",
0)
self.txin2_siganyonecanpay_none_amount = to_satoshis(0.007)
self.txout1_siganyonecanpay_none = TxOutput(
to_satoshis(0.008), self.p2pkh_addr.to_script_pub_key())
self.txout2_siganyonecanpay_none = TxOutput(
to_satoshis(0.007), self.p2pkh_addr.to_script_pub_key())
# SIGHASH_SINGLE | SIGHASH_ANYONECANPAY type send
self.txin1_siganyonecanpay_single = TxInput(
"c7bb5672266c8a5b64fe91e953a9e23e3206e3b1a2ddc8e5999b607b82485042",
0)
self.txin1_siganyonecanpay_single_amount = to_satoshis(0.01)
self.txout1_siganyonecanpay_single = TxOutput(
to_satoshis(0.005), self.p2pkh_addr.to_script_pub_key())
self.txout2_siganyonecanpay_single = TxOutput(
to_satoshis(0.0049), self.p2pkh_addr.to_script_pub_key())
# result
self.create_send_to_p2wpkh_result = "020000000178105e8743e15494e119a39702704ae9eeb45dd0f1c9cdabb7b7d666aa3a7b5a000000006b4830450221009ad68e1ecdd38d6abe515a52582a441a56f0fedb21816eb2f583183685da2eb502203c4fc7522ad7ab0c1854180cfd337e484ad3ba70d23bcf4380c6e2ff4e6e7985012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a546ffffffff01301b0f0000000000160014fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a00000000"
self.spend_p2pkh_result = "02000000000101d33a48a6073b8a504107e47671e9464e10457451a576531e0d3878c74c1ccab30000000000ffffffff0120f40e00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac0247304402201c7ec9b049daa99c78675810b5e36b0b61add3f84180eaeaa613f8525904bdc302204854830d463a4699b6d69e37c08b8d3c6158185d46499170cfcc24d4a9e9a37f012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54600000000"
self.p2pkh_and_p2wpkh_to_p2pkh_result = "02000000000102cc32915a633295794e8b2a9574cd02ff3eaa042b1c0bffb21fd668c879522a1e000000006a47304402200fe842622e656a6780093f60b0597a36a57481611543a2e9576f9e8f1b34edb8022008ba063961c600834760037be20f45bbe077541c533b3fd257eae8e08d0de3b3012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a546ffffffffda607a90ee1ccae095add81952d2e47a26e4dd75bce0d0bd04bf0f314790f3ff0000000000ffffffff01209a1d00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac00024730440220274bb5445294033a36c360c48cc5e441ba8cc2bc1554dcb7d367088ec40a0d0302202a36f6e03f969e1b0c582f006257eec8fa2ada8cd34fe41ae2aa90d6728999d1012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54600000000"
self.test_signone_send_result = "0200000000010142192f56f65d6d94a725ac1f11ebed8488bdd43e20bda6f9735da7008a334cfb0000000000ffffffff0200350c00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac30e60200000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac02483045022100d3e7d4fceb7cded91f5d09ef192b5308d325ead1047ee5972a62747b8a937da502205e6bdeebe048f7923be75e36b6d39a78891fccbf0084ac1445f27a77261a13c2022102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54600000000"
self.test_sigsingle_send_result = "02000000000101ebed7cf47df90daa155953aac97868a825f322d7d9c176d6569a23b5d40949b00000000000ffffffff0240420f00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88acc0090e00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac02483045022100e315efea11d21b0819425f164751e4bbdd20f7fee8b0ee949da466ee013b73b7022048cb056d4823272518023222b39cdead68dc3a9b1e60aae37a8dd5a5108d2a62032102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54600000000"
self.test_siganyonecanpay_all_send_result = "02000000000102366062f7512f38828fa46eb2f8d47db454c9e34348215e40edce4d56a2977ef60000000000ffffffffeb680f0460fe9c46d875409e7f0cd6502c3885304659d0be791ad17cb7ddaff40000000000ffffffff0220bf0200000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac10980200000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac02483045022100b963e68c5d133c16c0bb9cdf82c2ace5acd5c03fc03a4572699ac2712bbe772202202075cf8e35d4093e71635c49844a009a16ff08b9ee2ff5876ef2f3bd17b93c63812102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a5460247304402206fb60dc79b5ca6c699d04ec96c4f196938332c2909fd17c04023ebcc7408f36e02202b071771a58c84e20b7bf1fcec05c0ef55c1100436a055bfcb2bf7ed1c0683a9012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54600000000"
self.test_siganyonecanpay_none_send_result = "02000000000102959028c7ee77b7ea214e5c783b69e66b8457579b9c136987100f393f4a5daed20000000000fffffffff5f4e3eca1df79315f22eff3aeea5daf72d547ebe296dee672736726d46250ee0000000000ffffffff0200350c00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac60ae0a00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac0247304402203bbcbd2003244e9ccde7f705d3017f3baa2cb2d47efb63ede7e39704eff3987702206932aa4b402de898ff2fd3b2182f344dc9051b4c326dacc07b1e59059042f3ad822102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54602483045022100bd00b75aaefc0ab139f44b5347a8159d7158ae911bbf5a76f7fe1b93e2b0f1d50220724189279c0c497e15b4e3e1d1291f0b15e3dc460e8b2adf8597dbbd3af32440012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54600000000"
self.test_siganyonecanpay_single_send_result = "02000000000101425048827b609b99e5c8dda2b1e306323ee2a953e991fe645b8a6c267256bbc70000000000ffffffff0220a10700000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac107a0700000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac02483045022100ff22bf77115243a01f1c39eca2d3a222e1e176d272b3eab561b6d625af0ee21a0220520b07b72ba5ab11f33a0ed921aac29a05ad09cc65107f3931a25711679562b0832102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54600000000"
def main():
# always remember to setup the network
setup('testnet')
#
# This script spends from a P2SH address containing a CSV+P2PKH script as
# created from examples/create_p2sh_csv_p2pkh.py
#
# We assume that some 11.1 tBTC have been send to that address and that we know
# the txid and the specific UTXO index (or vout).
#
# set values
relative_blocks = 20
txid = '76c102821b916a625bd3f0c3c6e35d5c308b7c23e78b8866b06a3a466041db0a'
vout = 0
seq = Sequence(TYPE_RELATIVE_TIMELOCK, relative_blocks)
# create transaction input from tx id of UTXO (contained 11.1 tBTC)
txin = TxInput(txid, vout, sequence=seq.for_input_sequence())
# secret key needed to spend P2PKH that is wrapped by P2SH
p2pkh_sk = PrivateKey(
'cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9')
p2pkh_pk = p2pkh_sk.get_public_key().to_hex()
p2pkh_addr = p2pkh_sk.get_public_key().get_address()
# create the redeem script - needed to sign the transaction
redeem_script = Script([
seq.for_script(), 'OP_CHECKSEQUENCEVERIFY', 'OP_DROP', 'OP_DUP',
'OP_HASH160',
p2pkh_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
])
# to confirm that address is the same as the one that the funds were sent
#addr = P2shAddress.from_script(redeem_script)
#print(addr.to_string())
# send/spend to any random address
to_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
txout = TxOutput(to_satoshis(11), to_addr.to_script_pub_key())
# no change address - the remaining 0.1 tBTC will go to miners)
# create transaction from inputs/outputs
tx = Transaction([txin], [txout])
# print raw transaction
print("\nRaw unsigned transaction:\n" + tx.serialize())
# use the private key corresponding to the address that contains the
# UTXO we are trying to spend to create the signature for the txin -
# note that the redeem script is passed to replace the scriptSig
sig = p2pkh_sk.sign_input(tx, 0, redeem_script)
#print(sig)
# set the scriptSig (unlocking script) -- unlock the P2PKH (sig, pk) plus
# the redeem script, since it is a P2SH
txin.script_sig = Script([sig, p2pkh_pk, redeem_script.to_hex()])
signed_tx = tx.serialize()
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + signed_tx)
print("\nTxId:", tx.get_txid())
def setUp(self):
setup('testnet')
self.sk1 = PrivateKey.from_wif(
"cTALNpTpRbbxTCJ2A5Vq88UxT44w1PE2cYqiB3n4hRvzyCev1Wwo")
self.sk2 = PrivateKey.from_wif(
"cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9")
# 2-2 Multi-sign Script
self.p2wsh_script = Script([
'OP_2',
self.sk1.get_public_key().to_hex(),
self.sk2.get_public_key().to_hex(), 'OP_2', 'OP_CHECKMULTISIG'
])
# tb1q89t0jucv7un4qq85u0a0tkc9qkepvg3vra72r00msx58wqplewfsfrlunx
self.p2wsh_addr = P2wshAddress.from_script(self.p2wsh_script)
# n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR
self.p2pkh_addr = self.sk1.get_public_key().get_address()
# P2PKH to P2WSH
self.txin1 = TxInput(
"6e9a0692ed4b3328909d66d41531854988dc39edba5df186affaefda91824e69",
0)
self.txout1 = TxOutput(to_satoshis(0.0097),
self.p2wsh_addr.to_script_pub_key())
# P2WSH to P2PKH
self.txin_spend = TxInput(
"6233aca9f2d6165da2d7b4e35d73b039a22b53f58ce5af87dddee7682be937ea",
0)
self.txin_spend_amount = to_satoshis(0.0097)
self.txout2 = TxOutput(to_satoshis(0.0096),
self.p2pkh_addr.to_script_pub_key())
self.p2wsh_redeem_script = self.p2wsh_script
# Multiple input multiple output
# P2PKH UTXO
self.txin1_multiple = TxInput(
"24d949f8c77d7fc0cd09c8d5fccf7a0249178c16170c738da19f6c4b176c9f4b",
0)
self.txin1_multiple_amount = to_satoshis(0.005)
# P2WSH UTXO
self.txin2_multiple = TxInput(
"65f4d69c91a8de54dc11096eaa315e84ef91a389d1d1c17a691b72095100a3a4",
0)
self.txin2_multiple_amount = to_satoshis(0.0069)
# P2WPKH UTXO
self.txin3_multiple = TxInput(
"6c8fc6453a2a3039c2b5b55dcc59587e8b0afa52f92607385b5f4c7e84f38aa2",
0)
self.txin3_multiple_amount = to_satoshis(0.0079)
self.output1_multiple = TxOutput(to_satoshis(0.001),
self.p2wsh_addr.to_script_pub_key())
self.output2_multiple = TxOutput(
to_satoshis(0.001),
self.sk1.get_public_key().get_segwit_address().to_script_pub_key())
self.output3_multiple = TxOutput(to_satoshis(0.0177),
self.p2pkh_addr.to_script_pub_key())
# result
self.create_send_to_p2pkh_result = "0200000001694e8291daeffaaf86f15dbaed39dc8849853115d4669d9028334bed92069a6e000000006a473044022038516db4e67c9217b871c690c09f60a57235084f888e23b8ac77ba01d0cba7ae022027a811be50cf54718fc6b88ea900bfa9c8d3e218208fef0e185163e3a47d9a08012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a546ffffffff0110cd0e00000000002200203956f9730cf7275000f4e3faf5db0505b216222c1f7ca1bdfb81a877003fcb9300000000"
self.spend_p2pkh_result = "02000000000101ea37e92b68e7dedd87afe58cf5532ba239b0735de3b4d7a25d16d6f2a9ac33620000000000ffffffff0100a60e00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac040047304402205c88b6c247c6b59e1cc48493b66629b6c011d97b99ecf991b595e891542cf1a802204fa0e3c238818a65adc87a0b2511ba780e4b57ff6c1ba6b27815b1dca7b72c1c01483045022100cec7df71d36a37b979b693c9408ddc1f63325654566fd1b4ee7b6fc18ec601e502203ed5a2c68096d403686cf60b6c1d740b8ae254ec94fc4c35d54f70e4c59a28340147522102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a5462103a2fef1829e0742b89c218c51898d9e7cb9d51201ba2bf9d9e9214ebb6af3270852ae00000000"
self.multiple_input_multiple_ouput_result = "020000000001034b9f6c174b6c9fa18d730c17168c1749027acffcd5c809cdc07f7dc7f849d924000000006a47304402206932c93458a6ebb85f9fd6f69666cd383a3b8c8d517a096501438840d90493070220544d996a737ca9affda3573635b09e215be1ffddbee9b1260fc3d85d61d90ae5012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a546ffffffffa4a3005109721b697ac1d1d189a391ef845e31aa6e0911dc54dea8919cd6f4650000000000ffffffffa28af3847e4c5f5b380726f952fa0a8b7e5859cc5db5b5c239302a3a45c68f6c0000000000ffffffff03a0860100000000002200203956f9730cf7275000f4e3faf5db0505b216222c1f7ca1bdfb81a877003fcb93a086010000000000160014fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a10021b00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac000400483045022100ff3d84fea8f9ed0f467a4451846a834f94ee00538c5f70637540b8d3ec762e8802204f35aadacaff8e3c5b7d9ba9bb068141f6950feb9da68707249a485f519cbd9d01483045022100b0e1a9f73cb4674d780e24e0a1a7dc96719ce119eb2df2804653990ae2ca32e402203398b490e9caa872463191ba7a4ae84845a94d3b4025ee845491a9f71ea623390147522102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a5462103a2fef1829e0742b89c218c51898d9e7cb9d51201ba2bf9d9e9214ebb6af3270852ae024730440220733fcbd21517a1559e9561668e480ffd0a24b62520cfa16ca7689b20f7f82be402204f053a27f19e0bd1346676c74c65e9e452515bc6510ab307ac3a3fb6d3c89ca7012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a54600000000"