def create_HODL_address(key, lock, is_priv=False):
setup(os.getenv("BUY_LAMBO_BTC_NET", "regtest"))
# Get public key (given or found from private key)
public_key = PrivateKey(key).get_public_key() if is_priv else PublicKey(key)
# Get address from public key
address_from_key = public_key.get_address()
# Set lock sequence prefix
seq = Sequence(TYPE_ABSOLUTE_TIMELOCK, lock)
# create the redeem script - needed to sign the transaction
redeem_script = Script(
[
seq.for_script(),
"OP_CHECKLOCKTIMEVERIFY",
"OP_DROP",
"OP_DUP",
"OP_HASH160",
address_from_key.to_hash160(),
"OP_EQUALVERIFY",
"OP_CHECKSIG",
]
)
# create a P2SH address from a redeem script
addr = P2shAddress.from_script(redeem_script)
print("Time-locked address: {}".format(addr.to_string()))
def main():
# always remember to setup the network
setup('testnet')
# could also instantiate from existing WIF key
priv = PrivateKey.from_wif(
'cVdte9ei2xsVjmZSPtyucG43YZgNkmKTqhwiUA8M4Fc3LdPJxPmZ')
# compressed is the default
print("\nPrivate key WIF:", priv.to_wif(compressed=True))
# get the public key
pub = priv.get_public_key()
# compressed is the default
print("Public key:", pub.to_hex(compressed=True))
# get address from public key
address = pub.get_segwit_address()
# print the address and hash - default is compressed address
print("Native Address:", address.to_string())
segwit_hash = address.to_hash()
print("Segwit Hash:", segwit_hash)
print("Segwit Version:", address.get_type())
# test to_string
addr2 = P2wpkhAddress.from_hash(segwit_hash)
print("Created P2wpkhAddress from Segwit Hash and calculate address:")
print("Native Address:", addr2.to_string())
#
# display P2SH-P2WPKH
#
# create segwit address
addr3 = PrivateKey.from_wif(
'cTmyBsxMQ3vyh4J3jCKYn2Au7AhTKvqeYuxxkinsg6Rz3BBPrYKK').get_public_key(
).get_segwit_address()
# wrap in P2SH address
addr4 = P2shAddress.from_script(addr3.to_script_pub_key())
print("P2SH(P2WPKH):", addr4.to_string())
#
# display P2WSH
#
p2wpkh_key = PrivateKey.from_wif(
'cNn8itYxAng4xR4eMtrPsrPpDpTdVNuw7Jb6kfhFYZ8DLSZBCg37')
script = Script([
'OP_1',
p2wpkh_key.get_public_key().to_hex(), 'OP_1', 'OP_CHECKMULTISIG'
])
p2wsh_addr = P2wshAddress.from_script(script)
print("P2WSH of P2PK:", p2wsh_addr.to_string())
#
# display P2SH-P2WSH
#
p2sh_p2wsh_addr = P2shAddress.from_script(p2wsh_addr.to_script_pub_key())
print("P2SH(P2WSH of P2PK):", p2sh_p2wsh_addr.to_string())
def main():
# always remember to setup the network
setup('testnet')
#
# This script creates a P2SH address containing a CHECKSEQUENCEVERIFY plus
# a P2PKH locking funds with a key as well as for 20 blocks
#
# set values
relative_blocks = 20
seq = Sequence(TYPE_RELATIVE_TIMELOCK, relative_blocks)
# secret key corresponding to the pubkey needed for the P2SH (P2PKH) transaction
p2pkh_sk = PrivateKey(
'cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9')
# get the address (from the public key)
p2pkh_addr = p2pkh_sk.get_public_key().get_address()
# create the redeem script
redeem_script = Script([
seq.for_script(), 'OP_CHECKSEQUENCEVERIFY', 'OP_DROP', 'OP_DUP',
'OP_HASH160',
p2pkh_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
])
# create a P2SH address from a redeem script
addr = P2shAddress.from_script(redeem_script)
print(addr.to_string())
def main():
# always remember to setup the network
setup('regtest')
#
# This script creates a P2SH address containing a
# CHECKLOCKTIMEVERIFY plus a P2PKH locking funds with a key
# until a certain block_height is reached
#
# set values
block_height = 140
seq = Sequence(TYPE_ABSOLUTE_TIMELOCK, block_height)
# secret key corresponding to the pubkey needed for the P2SH (P2PKH) transaction
p2pkh_sk = PrivateKey('cSbKZh6a6wNUAQ8pr2KLKeZCQ4eJnFmN35wtReaoU4kCP97XQu6W')
# get the address (from the public key)
p2pkh_addr = p2pkh_sk.get_public_key().get_address()
# create the redeem script
redeem_script = Script([seq.for_script(), 'OP_CHECKLOCKTIMEVERIFY', 'OP_DROP', 'OP_DUP', 'OP_HASH160', p2pkh_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'])
# create a P2SH address from a redeem script
addr = P2shAddress.from_script(redeem_script)
print(addr.to_string())
class TestCreateP2shTransaction(unittest.TestCase):
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( 0.9, Script(['OP_ADD', 'OP_5', 'OP_EQUAL']) )
self.change_addr = P2pkhAddress('mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r')
self.change_txout = TxOutput( 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( 0.8, self.change_addr.to_script_pub_key())
self.spend_non_std_tx_result = '020000000163e6685168f60e72131de6f65e4bae8e5634085e3de85f877cb5d445af6b9a4d00000000025253ffffffff0100b4c404000000001976a914751e76e8199196d454941c45d1b3a323f1433bd688ac00000000'
def test_send_to_non_std(self):
tx = Transaction([self.txin], [self.txout, self.change_txout])
from_addr = P2pkhAddress('mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r')
sig = self.sk.sign_input( tx, 0, from_addr.to_script_pub_key() )
pk = self.sk.get_public_key().to_hex()
self.txin.script_sig = Script([sig, pk])
self.assertEqual(tx.serialize(), self.create_non_std_tx_result)
def test_spend_non_std(self):
tx = Transaction([self.txin_spend], [self.txout_spend])
self.assertEqual(tx.serialize(), self.spend_non_std_tx_result)
def main():
# 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(
Decimal('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(Decimal('0.29'), change_addr.to_script_pub_key())
#change_txout = TxOutput(Decimal('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 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 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()
pk = pk.to_hex()
#print (pk)
# set the scriptSig (unlocking script)
txin.script_sig = Script([sig, pk])
signed_tx = tx.serialize()
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + signed_tx)
def genAddress():
# Initialise bitcoin.py
setup('mainnet')
priv = PrivateKey()
wif = priv.to_wif(compressed=True)
return wif
def main():
# always remember to setup the network
setup('testnet') # same params as regest, which the node should run
# create transaction input from tx id of UTXO (contained 0.4 tBTC)
txin = TxInput(
'e2d08a63a540000222d6a92440436375d8b1bc89a2638dc5366833804287c83f', 1)
# create transaction output using P2PKH scriptPubKey (locking script)
addr = P2pkhAddress('msXP94TBncQ9usP6oZNpGweE24biWjJs2d')
# locking script expects 2 numbers that when added equal 5 (silly example)
txout = TxOutput(0.9, Script(['OP_ADD', 'OP_5', 'OP_EQUAL']))
# 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('mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r')
change_txout = TxOutput(2, change_addr.to_script_pub_key())
# create transaction from inputs/outputs -- default locktime is used
tx = Transaction([txin], [txout, change_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 sign the input
sk = PrivateKey('cMahea7zqjxrtgAbB7LSGbcQUr1uX1ojuat9jZodMN87JcbXMTcA')
# 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('mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r')
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()
pk = pk.to_hex()
#print (pk)
# set the scriptSig (unlocking script)
txin.script_sig = Script([sig, pk])
signed_tx = tx.serialize()
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + signed_tx)
def test_p2sh_p2wpkh_creation_pubkey(self):
addr = PrivateKey.from_wif(
'cTmyBsxMQ3vyh4J3jCKYn2Au7AhTKvqeYuxxkinsg6Rz3BBPrYKK'
).get_public_key().get_segwit_address()
p2sh_addr = P2shAddress.from_script(addr.to_script_pub_key())
self.assertTrue(p2sh_addr.to_string(),
self.correct_p2sh_p2wpkh_address)
def get_function2_priv_key_obj_from_conf(function2_conf_section):
priv_key_from_str = Common.get_config_value(function2_conf_section,
'private_key_from')
priv_key_from_obj = PrivateKey(priv_key_from_str)
return priv_key_from_obj
def get_pub_key_hash_from_priv_key_obj(priv_key_str):
"""
priv key to pub hash
"""
priv_key_obj = PrivateKey.from_wif(priv_key_str)
pub_key_obj = priv_key_obj.get_public_key()
pub_key_hash160 = pub_key_obj.get_address().to_hash160()
return pub_key_hash160
def setUp(self):
setup('testnet')
self.priv = PrivateKey.from_wif('cVdte9ei2xsVjmZSPtyucG43YZgNkmKTqhwiUA8M4Fc3LdPJxPmZ')
self.pub = self.priv.get_public_key()
self.correct_p2wpkh_address = 'tb1qxmt9xgewg6mxc4mvnzvrzu4f2v0gy782fydg0w'
self.correct_p2sh_p2wpkh_address = '2N8Z5t3GyPW1hSAEJZqQ1GUkZ9ofoGhgKPf'
self.correct_p2wsh_address = 'tb1qy4kdfavhluvnhpwcqmqrd8x0ge2ynnsl7mv2mdmdskx4g3fc6ckq8f44jg'
self.correct_p2sh_p2wsh_address = 'tb1qy4kdfavhluvnhpwcqmqrd8x0ge2ynnsl7mv2mdmdskx4g3fc6ckq8f44jg'
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'])
#TODELETE
#txin_script_pub_key = redeem_script.to_p2sh_script_pub_key()
to_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
txout = TxOutput(Decimal('0.08'), 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_pub_key_from_priv_key_obj(priv_key_str):
"""
priv to pub key object
"""
priv_key_obj = PrivateKey.from_wif(priv_key_str)
pub_key_obj = priv_key_obj.get_public_key()
return pub_key_obj
def main():
# always remember to setup the network
setup('testnet')
priv1 = PrivateKey("cN1XE3ESGgdvr4fWsB7L3BcqXncUauF8Fo8zzv4Sm6WrkiGrsxrG")
priv2 = PrivateKey("cR8AkcbL2pgBswrHp28AftEznHPPLA86HiTog8MpNCibxwrsUcZ4")
p2sh_redeem_script = Script(
['OP_1', priv1.get_public_key().to_hex(), priv2.get_public_key().to_hex(),'OP_2', 'OP_CHECKMULTISIG'])
fromAddress = P2wshAddress.from_script(p2sh_redeem_script)
toAddress = P2wpkhAddress.from_address("tb1qtstf97nhk2gycz7vl37esddjpxwt3ut30qp5pn")
# set values
txid = '2042195c40a92353f2ffe30cd0df8d177698560e81807e8bf9174a9c0e98e6c2'
vout = 0
amount = 0.01
# create transaction input from tx id of UTXO
txin = TxInput(txid, vout)
txOut1 = TxOutput(0.0001, toAddress.to_script_pub_key())
txOut2 = TxOutput(0.0098, fromAddress.to_script_pub_key())
tx = Transaction([txin], [txOut1, txOut2], has_segwit=True)
sig1 = priv1.sign_segwit_input(tx, 0, p2sh_redeem_script, amount)
tx.witnesses.append(Script(['OP_0', sig1, p2sh_redeem_script.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("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())
class Id:
"""
Helper class for handling identity related keys and addresses easily
"""
def __init__(self, sk: str):
self.sk = PrivateKey(secret_exponent=int(sk, 16))
self.pk = self.sk.get_public_key()
self.addr = self.pk.get_address().to_string()
self.p2pkh = P2pkhAddress(self.addr).to_script_pub_key()
def test_p2wsh_creation_1multisig(self):
p2wpkh_key = PrivateKey.from_wif(
'cNn8itYxAng4xR4eMtrPsrPpDpTdVNuw7Jb6kfhFYZ8DLSZBCg37')
script = Script([
'OP_1',
p2wpkh_key.get_public_key().to_hex(), 'OP_1', 'OP_CHECKMULTISIG'
])
p2wsh_addr = P2wshAddress.from_script(script)
self.assertTrue(p2wsh_addr.to_string(), self.correct_p2wsh_address)
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"
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 setUp(self):
setup('mainnet')
self.message = "The test!"
self.key_wifc = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn"
self.priv = PrivateKey.from_wif(self.key_wifc)
self.pub = self.priv.get_public_key()
self.address = self.pub.get_address().to_string()
self.external_address = '1LbxJuEHPsoFRVo3qM1YJRg7DfRD1RvUDe'
self.deterministic_signature = 'IEiQ7kHfGqlxHSOcUftzR4gChjupJbuIIJCiY3LryQ9SXwPeRoBtJYkrNd/rgU7RP9jX6i2IaGGYMLt9bW+/bbI='
self.external_signature = 'H+yEsMrKoLqcdegOxYbZ4MFpQkRJligl1whXQDY2+g7EptxmOj9vC3n5ykdHkof0qEbmyV62syaKh+9C95V5R34='
def main():
# always remember to setup the network
setup('testnet')
#
# This script creates a P2SH address containing a P2PK script and sends
# some funds to it
#
# create transaction input from tx id of UTXO (contained 0.1 tBTC)
txin = TxInput(
'76464c2b9e2af4d63ef38a77964b3b77e629dddefc5cb9eb1a3645b1608b790f', 0)
# address we are spending from
from_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
# secret key of address that we are trying to spent
sk = PrivateKey('cTALNpTpRbbxTCJ2A5Vq88UxT44w1PE2cYqiB3n4hRvzyCev1Wwo')
#
# create transaction output using P2SH scriptPubKey (locking script)
# (the recipient will give us the final address but for now we create it
# for demonstration purposes)
#
# secret key corresponding to the pubkey needed for the P2SH (P2PK) transaction
p2pk_sk = PrivateKey(
'cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9')
p2pk_pk = p2pk_sk.get_public_key().to_hex()
redeem_script = Script([p2pk_pk, 'OP_CHECKSIG'])
txout = TxOutput(Decimal('0.09'), redeem_script.to_p2sh_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
sig = sk.sign_input(tx, 0, from_addr.to_script_pub_key())
#print(sig)
# get public key as hex
pk = sk.get_public_key()
pk = pk.to_hex()
#print (pk)
# set the scriptSig (unlocking script)
txin.script_sig = Script([sig, pk])
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 sign(self, b):
assert isinstance(b, bytes), 'Input must be bytes object; Keypair.sign'
setup('mainnet')
hs = sha256(b).digest
wif = self.priv.key
pk = PrivateKey(wif=wif)
sk = ecdsa.SigningKey.from_string(pk.key.to_string(), curve=SECP256k1)
return sk.sign(hs, hashfunc=hashlib.sha256, sigencode=sigencode_der_canonize)
def getAddress(id: str):
# Initialise bitcoin.py
setup('mainnet')
wif = db.getWIF(id)
priv = PrivateKey.from_wif(f"{wif}")
pub = priv.get_public_key()
address = pub.get_segwit_address().to_string()
return address
def setUp(self):
setup('testnet')
self.txin = TxInput(
"76464c2b9e2af4d63ef38a77964b3b77e629dddefc5cb9eb1a3645b1608b790f",
0)
self.from_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
self.sk = PrivateKey(
'cTALNpTpRbbxTCJ2A5Vq88UxT44w1PE2cYqiB3n4hRvzyCev1Wwo')
self.p2pk_sk = PrivateKey(
'cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9')
self.p2pk_redeem_script = Script(
[self.p2pk_sk.get_public_key().to_hex(), 'OP_CHECKSIG'])
self.txout = TxOutput(to_satoshis(0.09),
self.p2pk_redeem_script.to_p2sh_script_pub_key())
self.create_p2sh_and_send_result = '02000000010f798b60b145361aebb95cfcdedd29e6773b4b96778af33ed6f42a9e2b4c4676000000006b483045022100fd3a3fd4aeec5db0f3f9c5c5ef7f60f37920be7464a80edacbc3b6b9d0624173022031ce309330e60b19d39cec8c5597460c840adcdd66f7dbbf896eef3ec42b472f012102d82c9860e36f15d7b72aa59e29347f951277c21cd4d34822acdeeadbcff8a546ffffffff01405489000000000017a9142910fc0b1b7ab6c9789c5a67c22c5bcde5b903908700000000'
self.txin_spend = TxInput(
'7db363d5a7fabb64ccce154e906588f1936f34481223ea8c1f2c935b0a0c945b',
0)
# self.p2pk_sk , self.p2pk_redeem_script from above
self.to_addr = self.from_addr
self.txout2 = TxOutput(to_satoshis(0.08),
self.to_addr.to_script_pub_key())
self.spend_p2sh_result = '02000000015b940c0a5b932c1f8cea231248346f93f18865904e15cecc64bbfaa7d563b37d000000006c47304402204984c2089bf55d5e24851520ea43c431b0d79f90d464359899f27fb40a11fbd302201cc2099bfdc18c3a412afb2ef1625abad8a2c6b6ae0bf35887b787269a6f2d4d01232103a2fef1829e0742b89c218c51898d9e7cb9d51201ba2bf9d9e9214ebb6af32708acffffffff0100127a00000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac00000000'
# P2SH(CSV+P2PKH)
self.sk_csv_p2pkh = PrivateKey(
'cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9')
self.seq = Sequence(TYPE_RELATIVE_TIMELOCK, 200)
self.txin_seq = TxInput(
'f557c623e55f0affc696b742630770df2342c4aac395e0ed470923247bc51b95',
0,
sequence=self.seq.for_input_sequence())
self.another_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
self.spend_p2sh_csv_p2pkh_result = '0200000001951bc57b24230947ede095c3aac44223df70076342b796c6ff0a5fe523c657f5000000008a483045022100c123775e69ec27094f7940facb9ad769c09f48a7fc88250a2fce67bd92c9b4cf02204ebdbed84af46e584fe6db9a23c420b7370879e883b555e119465f84bf34d82f012103a2fef1829e0742b89c218c51898d9e7cb9d51201ba2bf9d9e9214ebb6af327081e02c800b27576a914c3f8e5b0f8455a2b02c29c4488a550278209b66988acc80000000100ab9041000000001976a914fd337ad3bf81e086d96a68e1f8d6a0a510f8c24a88ac00000000'
def main() :
setup('testnet')
relative_blocks = 20
seq = Sequence(TYPE_RELATIVE_TIMELOCK, relative_blocks)
p2pkh_sk = PrivateKey('cRvyLwCPLU88jsyj94L7iJjQX5C2f8koG4G2gevN4BeSGcEvfKe9')
p2pkh_addr = p2pkh_sk.get_public_key().get_address()
print("Address : " + p2pkh_addr.to_string())
redeem_script = Script([seq.for_script(), 'OP_CHECKSEQUENCEVERIFY', 'OP_DROP', 'OP_DUP', 'OP_HASH160'
, p2pkh_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'])
addr = P2shAddress.from_script(redeem_script)
print(addr.to_string())
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('tb1qlffsz7cgzmyzhklleu97afru7vwjytux4z4zsl')
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 main():
# always remember to setup the network
setup('mainnet')
# create a private key (deterministically)
priv = PrivateKey(secret_exponent=1)
# compressed is the default
print("\nPrivate key WIF:", priv.to_wif(compressed=True))
# could also instantiate from existing WIF key
#priv = PrivateKey.from_wif('KwDiBf89qGgbjEhKnhxjUh7LrciVRzI3qYjgd9m7Rfu73SvHnOwn')
# get the public key
pub = priv.get_public_key()
# compressed is the default
print("Public key:", pub.to_hex(compressed=True))
# get address from public key
address = pub.get_address()
# print the address and hash160 - default is compressed address
print("Address:", address.to_string())
print("Hash160:", address.to_hash160())
print("\n--------------------------------------\n")
# sign a message with the private key and verify it
message = "The test!"
signature = priv.sign_message(message)
print("The message to sign:", message)
print("The signature is:", signature)
if PublicKey.verify_message(address.to_string(), signature, message):
print("The signature is valid!")
else:
print("The signature is NOT valid!")
def tx_encf(self, vk_p, ct_c, user_conf_file_path):
user_conf_file = open(user_conf_file_path)
conf = json.load(user_conf_file)
sk_u = conf['SK']
sk_u = PrivateKey(secret_exponent=int(sk_u, 16))
vk_u = sk_u.get_public_key()
addr_u = vk_u.get_address().to_string()
#txid = '826711590bb543028418d312cf2229eba1b4fbf295fa73dbc37654085e1fc925'
#txid = '49ab8b8f6913d5fb97c067fe9466710f62e195bab5366e484d1b2334a5b5c0c8'
#tx_index = 1
txid = input(
"Fund the address: {0} \nand insert the txid:\n".format(addr_u))
tx_index = input("tx_index:\n")
print("txid: ", txid)
print("tx_index: ", tx_index)
signed_tx_hex = self._tx_encf('04' + vk_p, ct_c, sk_u, txid,
int(tx_index))
#tx_hash = "88e602cc4766edd442ee99270f2e94bf6f7625a9b49721311fc9bba4dfe8defa"
tx_hash = self.proxy.sendrawtransaction(signed_tx_hex)
return tx_hash
def tx_encf(self, vk_p, ct_c, user_conf_file_path):
user_conf_file = open(user_conf_file_path)
conf = json.load(user_conf_file)
self.challenge_len = conf['CHA_LEN']
self.response_len = conf['RES_LEN']
#--------------------import the private key of the user to wallet and fund it----------------
sk_u = conf['SK']
sk_u = PrivateKey(secret_exponent=int(sk_u, 16))
cmd = os.popen(zcash_cli + " " + conf_file + ' importprivkey ' +
sk_u.to_wif() + ' \"label\" false')
addr_u = cmd.read()
print("\nuser's address: ", addr_u)
# ---------------------setup a change shielded address for the user----------------------------
cmd = os.popen(zcash_cli + " " + conf_file +
' z_getnewaddress ') # create a new shielded address
self.public_address_user_shielded = cmd.read()
#self.public_address_user_shielded ="ztestsapling13y3ujgw6swemw4lhlk9786g3wngfgqmxjdy7f0d5wg6jz0yvmntnk5u4agvxt3zptght5rftmtj"
print("change shielded address: ", self.public_address_user_shielded)
cmd = os.popen(
zcash_cli + " " + conf_file + ' z_exportkey ' +
self.public_address_user_shielded) # export the private key
sk_change_shielded = cmd.read()
print("paying shielded private key: ", sk_change_shielded)
#---------------------setup the tx to send-----------------------------
tx = ' \'[{\"address\": \"' + addr_u.strip() + '\", \"amount\":0.82},' + \
'{\"address\": \"' + public_address_user_shielded.strip() + '\", \"amount\":0},' + \
'{ \"address\": \"' + public_address_decoder_shielded.strip() + '\", \"amount\":0.01, \"memo\": \"' \
+ ct_c + self.public_address_user_shielded.encode().hex() + '\"}]\''
cmd = zcash_cli + ' ' + conf_file + ' z_sendmany ' + addr_u.strip(
) + tx + ' 1 0'
tx_operation_id = os.popen(cmd).read()
print("tx1 operation id: ", tx_operation_id)
return tx_operation_id
