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')
#
# 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 spend_all():
""" creates & broadcasts a transactions that spend all UTXOs from the P2SH"""
# loads script data (Script, p2sh_addr)
script, p2sh_addr = csv_script(recreate=True)
# load transaction data(PrivateKey, timelock, P2pkhAddresses) from data.json
data = tools.load_data_json(priv=True, timelock_tx=True, p2pk=True)
priv_key = data['priv_key']
tx_lock = data['timelock_tx']
p2pkh_addr = data['p2pk_addr']
# query cli to detect transactions send to the p2sh adddress
# gathers txid, vout, and amount of p2sh's UTXOs to create TxInputs
p2sh_utxos, p2sh_balance = [], 0
wallet_txs = tools.talk_to_cli('bitcoin-cli listtransactions * 900', True)
for tx in json.loads(wallet_txs):
if tx['address'] == p2sh_addr and tx['category'] == 'send':
p2sh_utxos.append(TxInput(tx['txid'], tx['vout'], sequence=tx_lock))
p2sh_balance += (-tx['amount'])
# confirm that bitcoin-cli was able to locate transactions to p2sh address
if not p2sh_utxos:
errors.missing_utxos() # prints error msg & raises systemExit
# check current network fees and compute fee estimate
resp = requests.get('https://api.blockcypher.com/v1/btc/test3').json()
fee_per_kb = resp['medium_fee_per_kb']
# per Output: 34 bytes | per Input: 200 bytes (estimate)
script_size = 1 * 34 + len(p2sh_utxos) * 200
fee = (script_size * fee_per_kb) / 100000000
if fee >= p2sh_balance:
fee = tools.user_custom_fee(fee, p2sh_balance)
# create and sign transaction
tx_out = TxOutput((p2sh_balance-fee), p2pkh_addr.to_script_pub_key())
# no change address, spending entire balance
tx = Transaction(p2sh_utxos, [tx_out])
pub_key = priv_key.get_public_key().to_hex()
for i, txin in enumerate(p2sh_utxos):
sig = priv_key.sign_input(tx, i, script)
txin.script_sig = Script([sig, pub_key, script.to_hex()])
tx_signed, tx_id = tx.serialize(), tx.get_txid()
# writes tx_id into data.json and displays tx_signed (+details) to the user
tools.update_data_json(outputs={'tx_id': tx_id, 'tx_signed': tx_signed})
print('\nSpending from P2SH transaction')
print(' -> to_addr:', p2pkh_addr.to_address())
print(' -> amount:', p2sh_balance-fee)
print(' -> fee:', fee)
print(' -> tx_id:', tx_id)
print(' -> tx_signed:',tx_signed, '\n')
# broadcast signed transaction over bitcoin-cli
r = tools.talk_to_cli(f'bitcoin-cli sendrawtransaction {tx_signed}', True)
if len(r) == 64:
print('\nTransaction broadcasted via bitcoin-cli successfully\n')
def test_signed_low_s_SIGNONE_tx_1_input_2_outputs(self):
tx = Transaction([self.txin], [self.txout, self.change_low_s_txout])
sig = self.sk.sign_input( tx, 0, Script(['OP_DUP', 'OP_HASH160',
self.from_addr.to_hash160(),
'OP_EQUALVERIFY', 'OP_CHECKSIG']),
SIGHASH_NONE)
pk = self.sk.get_public_key().to_hex()
self.txin.script_sig = Script([sig, pk])
# check correct raw tx
self.assertEqual(tx.serialize(),
self.core_tx_signed_low_s_SIGNONE_result)
# check correct calculation of txid
self.assertEqual(tx.get_txid(), self.core_tx_signed_low_s_SIGNONE_txid)
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 main():
# always remember to setup the network
setup('testnet')
priv0 = PrivateKey("cN1XE3ESGgdvr4fWsB7L3BcqXncUauF8Fo8zzv4Sm6WrkiGrsxrG")
pub = priv0.get_public_key()
fromAddress = pub.get_segwit_address()
priv1 = PrivateKey("cN1XE3ESGgdvr4fWsB7L3BcqXncUauF8Fo8zzv4Sm6WrkiGrsxrG")
# P2SH Script: OP_M <Public key 1> <Public key 2> ... OP_N OP_CHECKMULTISIG
p2sh_redeem_script = Script(
['OP_1',
priv1.get_public_key().to_hex(), 'OP_1', 'OP_CHECKMULTISIG'])
toAddress = P2wshAddress.from_script(p2sh_redeem_script)
# set values
txid = 'd222d91e2da368ac38e84aa615c557e4caeacce02aa5dbca10d840fd460fc938'
vout = 0
amount = Decimal('0.01764912')
# create transaction input from tx id of UTXO
txin = TxInput(txid, vout)
redeem_script1 = Script([
'OP_DUP', 'OP_HASH160',
priv0.get_public_key().to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
])
# create transaction output
txOut1 = TxOutput(Decimal('0.0001'), toAddress.to_script_pub_key())
txOut2 = TxOutput(Decimal('0.01744912'), fromAddress.to_script_pub_key())
# create transaction
tx = Transaction([txin], [txOut1, txOut2], has_segwit=True)
print("\nRaw transaction:\n" + tx.serialize())
sig1 = priv0.sign_segwit_input(tx, 0, redeem_script1, amount)
tx.witnesses.append(Script([sig1, 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("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 buy_lambo(key, lock, from_addr, to_addr):
setup(os.getenv("BUY_LAMBO_BTC_NET", "regtest"))
# Create a proxy to JSON-RPC api
chain = NodeProxy(os.getenv("BUY_LAMBO_RPC_USER", "rpcuser"),
os.getenv("BUY_LAMBO_RPC_PASSWORD",
"rpcpassword")).get_proxy()
# Try executing a command to see if node is running
try:
chain.getblockcount()
except Exception:
print("Error: Node isn't working!")
return
# Check addresses
if not chain.validateaddress(from_addr)["isvalid"]:
print("Error: `from_addr` is not a valid address!")
return
if not chain.validateaddress(to_addr)["isvalid"]:
print("Error: `to_addr` is not a valid address!")
return
# Set lock sequence prefix
seq = Sequence(TYPE_ABSOLUTE_TIMELOCK, lock)
# Get public key (found from private key)
private_key = PrivateKey(key)
public_key = private_key.get_public_key()
# Add address to wallet so we can get utxos from bitcoin core
chain.importaddress(from_addr)
# Get UTXOs
utxos = chain.listunspent(1, 9999999, [from_addr])
# Create inputs
txin = []
total_btc = Decimal(0)
for utxo in utxos:
# Note that for each input we set the correct nSequence
txin.append(
TxInput(utxo["txid"],
utxo["vout"],
sequence=seq.for_input_sequence()))
total_btc = total_btc + utxo["amount"]
if total_btc == 0:
return print("\nThere aren't any UTXOs :(.")
# Create a fee-less output
txout = TxOutput(total_btc - Decimal(0.1),
P2pkhAddress(to_addr).to_script_pub_key())
# Create dummy transaction (to calculate size)
tx = Transaction([TxInput.copy(inpt) for inpt in txin], [txout],
locktime=Locktime(lock).for_transaction())
# create the redeem script - needed to sign the transaction
redeem_script = Script([
seq.for_script(),
"OP_CHECKLOCKTIMEVERIFY",
"OP_DROP",
"OP_DUP",
"OP_HASH160",
public_key.get_address().to_hash160(),
"OP_EQUALVERIFY",
"OP_CHECKSIG",
])
# 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
for ind, txinput in enumerate(tx.inputs):
sig = private_key.sign_input(tx, ind, redeem_script)
txinput.script_sig = Script(
[sig, public_key.to_hex(),
redeem_script.to_hex()])
# Calculate fees
sat_per_byte = requests.get(
"https://bitcoinfees.earn.com/api/v1/fees/recommended").json(
)["fastestFee"]
fee = Decimal(
max((len(bytes.fromhex(tx.serialize())) * sat_per_byte) /
SATOSHIS_PER_BITCOIN, 0))
if fee == 0:
print("WARNING: There isn't enough balance to calculate fees.")
# Create final tx with correct txout value
txout = TxOutput(total_btc - fee,
P2pkhAddress(to_addr).to_script_pub_key())
tx = Transaction([TxInput.copy(inpt) for inpt in tx.inputs], [txout],
locktime=Locktime(lock).for_transaction())
for ind, txinput in enumerate(tx.inputs):
sig = private_key.sign_input(tx, ind, redeem_script)
txinput.script_sig = Script(
[sig, public_key.to_hex(),
redeem_script.to_hex()])
signed_tx = tx.serialize()
# print raw transaction
print("\nRaw unsigned transaction:\n{}".format(
Transaction(txin, [txout]).serialize()))
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n{}".format(signed_tx))
print("\nTxId: {}".format(tx.get_txid()))
# Check if is valid and send it
if chain.testmempoolaccept([signed_tx])[0]["allowed"]:
chain.sendrawtransaction(signed_tx)
print("\nSent to Block-chain! Have fun with those {} BTC.".format(
total_btc - fee))
else:
print("\nCan't send (yet)!")
print("Reason: `{}`".format(
chain.testmempoolaccept([signed_tx])[0]["reject-reason"]))
def main():
# always remember to setup the network
setup('regtest')
# RPC credentials for communicating with the node
rpcuser = '******'
rpcpass = '******'
proxy = NodeProxy(rpcuser, rpcpass).get_proxy()
# set values
block_height = 140
# secret key needed to spend P2PKH that is wrapped by P2SH
p2pkh_sk = PrivateKey(
'cSbKZh6a6wNUAQ8pr2KLKeZCQ4eJnFmN35wtReaoU4kCP97XQu6W')
# this is the P2SH address the funds have been locked in
p2shaddress = '2NGWStpuXtke1VXCTgNnzUgWbun7eY2f3nH'
# this is the address the funds will be sent to
to_addr = P2pkhAddress('mnS1ng5D1hdvLkYAK2oS8R1C4e37aQdVoC')
seq = Sequence(TYPE_ABSOLUTE_TIMELOCK, block_height)
lock = Locktime(block_height)
# import the address as watch-only
print('importaddress')
proxy.importaddress(p2shaddress, "P2SH absolute timelock", True)
# find all UTXOs for this address. 10.000.000 should be enough
print('listunspent')
list_unspent = proxy.listunspent(0, 9999999, [p2shaddress])
# create transaction inputs for all UTXOs. Calculate the total amount of
# bitcoins they contain
txin_list = []
total_amount = 0
for i in list_unspent:
txin = TxInput(i['txid'], i['vout'], sequence=seq.for_input_sequence())
txin_list.append(txin)
total_amount = total_amount + i['amount']
if total_amount == 0:
print("No funds to move")
sys.exit(0)
# derive public key and adddress from the private key
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_CHECKLOCKTIMEVERIFY', 'OP_DROP', 'OP_DUP',
'OP_HASH160',
p2pkh_addr.to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
])
# get fees using API. Although we may be running in regtest, we'll use the
# fees as if we were using testnet (fees are in satoshis)
url = 'https://api.blockcypher.com/v1/btc/test3'
resp = requests.get(url)
fee_per_kb = resp.json()['medium_fee_per_kb']
# calculate transaction size according to:
# in*180 + out*34 + 10 plus or minus 'in'
# https://bitcoin.stackexchange.com/questions/1195/how-to-calculate-transaction-size-before-sending-legacy-non-segwit-p2pkh-p2sh
# we'll play it safe and use the upper bound
tx_size = len(txin_list) * 180 + 34 + 10 + len(txin_list)
fees = tx_size * fee_per_kb / (1024 * 10**8)
print('fees:', fees)
# create the output
txout = TxOutput(
Decimal(total_amount) - Decimal(fees), to_addr.to_script_pub_key())
# create transaction from inputs/outputs
tx = Transaction(txin_list, [txout], lock.for_transaction())
# use the private key corresponding to the address that contains the
# UTXO we are trying to spend to create the signatures for all txins -
# note that the redeem script is passed to replace the scriptSig
for i, txin in enumerate(txin_list):
sig = p2pkh_sk.sign_input(tx, i, redeem_script)
# 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()])
# serialize the transaction
signed_tx = tx.serialize()
# test if the transaction will be accepted by the mempool
print('testmempoolaccept')
res = proxy.testmempoolaccept([signed_tx])
print(res)
if not res[0]['allowed']:
print("Transaction not valid")
sys.exit(1)
# print raw transaction
print("\nRaw unsigned transaction:\n" + tx.serialize())
# print raw signed transaction ready to be broadcasted
print("\nRaw signed transaction:\n" + signed_tx)
print("\nTxId:", tx.get_txid())
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_address())
# send/spend to any random address
to_addr = P2pkhAddress('n4bkvTyU1dVdzsrhWBqBw8fEMbHjJvtmJR')
txout = TxOutput(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 __init__(self,
ft: Transaction,
id_l: Id,
id_r: Id,
secret_l,
secret_r,
val_l: float,
val_r: float,
fee: float,
timelockCT: int = consts.timelockCT):
self.ft = ft
self.id_l = id_l
self.id_r = id_r
self.fee = fee
self.timelockCT = timelockCT
self.timelock = consts.timelock
self.val_l = val_l
self.val_r = val_r
self.transactions = []
id_as_l = Id(
'e12048ff047a0f15bcf977c86181828f5e05dbfe4cf1efe9af6362c8d53a00a3'
) # This is the sk that is leaking l's the adaptor signature in the real world
secret_rev_l = gen_secret()
id_as_r = Id(
'e12048ff047a0f15bcf977c86181828f5e05dbfe4cf1eee9af6362c8d53a02c1'
) # This is the sk that is leaking r's the adaptor signature in the real world
secret_rev_r = gen_secret()
ct = txs.get_gen_ct_tx(TxInput(ft.get_txid(), 0), id_l, id_r, id_as_l,
hash256(secret_rev_l), id_as_r,
hash256(secret_rev_r), val_l + val_r, fee, 0x2)
ct_script = ct.outputs[0].script_pubkey.script
ct_punish_l = txs.get_gen_punish_tx(TxInput(ct.get_txid(), 0),
id_l,
ct_script,
id_as_r,
secret_rev_r,
val_l + val_r - self.fee,
fee,
l=True)
ct_punish_r = txs.get_gen_punish_tx(TxInput(ct.get_txid(), 0),
id_r,
ct_script,
id_as_l,
secret_rev_l,
val_l + val_r - self.fee,
fee,
l=False)
ct_spend = txs.get_gen_split_tx(TxInput(ct.get_txid(), 0), id_l, id_r,
ct_script, val_l - 0.5 * fee,
val_r - 0.5 * fee, fee)
self.transactions.append(('CT', ct))
self.transactions.append(('CT spend', ct_spend))
self.transactions.append(
('CT_punish_l', ct_punish_l)
) # in the real world, the secret for this transaction is shared when the state is revoked
self.transactions.append(
('CT_punish_r', ct_punish_r)
) # in the real world, the secret for this transaction is shared when the state is revoked
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 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'])
#TESTE_SUZANA
addressObj = P2shAddress.from_script(redeem_script)
print("addressObj=" + addressObj.to_address())
#TESTE_SUZANA
# you can initially spend a specific UTXO that you know (e.g. with the txid after you send some funds to the address). Then if everything works you can use the address to find all tx in that address and spend them. Make sure the timelock works and that you can spend the funds as expected.
# The 2nd program should display the raw signed transaction that is to be sent to a bitcoin node plus _send_ the transaction to a node. The last part is not possible with the bitcoin-utils library since I have not impl. a node proxy yet. So you have to use another lib or finish with the cli commands (commented out of course) that I have to run in order to send the raw tx to a bitcoin node.
# The P2SH addr could be recalculated in 2nd program since we have the redeem script! Providing the P2SH addr saves you from this small calculation and 'connects' the 2 programs :-)
# Re fees, I would rather you calculate the 'appropriate' fee and explain in comments how/why you did it this way. Ideally, you would consult an online service to get an estimate of the appropriate fee. This is minor for assignment purposes but major for production systems.
#https://bitcoin.stackexchange.com/questions/83650/how-does-nsequence-check-sequence-verify-work
#The 2nd program requires a private key as well... that is what unlock the funds.
##### NAO PRECISA PARA O ASSIGNMENT DAQUI EM DIANTE #######
# 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')
#SUZANA ---- ASSINA COM P2SH do SCRIPT
txout = TxOutput(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 spend_p2sh_cltv_p2pkh(proxy, block_height, sender_priv_key, p2sh_addr,
rec_addr):
"""
Spends funds from a P2SH address with an absolute locktime to a P2PKH receiver address.
:param proxy: JSON RPC proxy for connecting to the network.
:param block_height: Block height the lock is valid for.
:param sender_priv_key: Private key of the address locking the funds.
:param p2sh_addr: P2SH address containing the funds.
:param rec_addr: P2PKH address receiving the funds.
"""
# mine 100 blocks and send bitcoin to the P2SH address
proxy.generatetoaddress(100, p2sh_addr)
# mine 100 blocks to make mined bitcoin spendable, emulates 'bitcoin-cli -generate 100'
for _ in range(100):
proxy.generatetoaddress(1, proxy.getnewaddress())
# retrieve unspent UTXOs for the P2SH address
p2sh_addr_unspent = proxy.listunspent(0, 99999999, [p2sh_addr])
# create absolute-block locking sequence for the transaction inputs
seq = Sequence(TYPE_ABSOLUTE_TIMELOCK, block_height)
# create transaction inputs for unspent UTXOs
# and calculate the total unspent bitcoins they contain
tx_inputs = []
total_unspent = 0
for utxo in p2sh_addr_unspent:
tx_inputs.append(
TxInput(utxo['txid'],
utxo['vout'],
sequence=seq.for_input_sequence()))
total_unspent += utxo['amount']
print("Unspent bitcoin in address {} : {}".format(p2sh_addr,
total_unspent))
# get the public key of the receiving address for the funds to be sent to
rec_pub_key = proxy.getaddressinfo(rec_addr)['pubkey']
rec_pk = PublicKey(rec_pub_key)
# calculate fee
satoshis_per_kb = requests \
.get('https://api.blockcypher.com/v1/btc/test3') \
.json()['medium_fee_per_kb']
# formula: |inputs| * 180 + 34 * |outputs| +- |inputs|
tx_size = len(tx_inputs) * 180 + 34 * 1 + 10 + len(tx_inputs)
# we calculate fees in terms of bitcoin
fee = (tx_size / 1024) * (satoshis_per_kb / 10e8)
# create the transaction output
tx_output = TxOutput(to_satoshis(Decimal(total_unspent) - Decimal(fee)),
rec_pk.get_address().to_script_pub_key())
# set a lock time in blocks for the transaction
lock = Locktime(block_height)
# create the transaction
tx = Transaction(tx_inputs, [tx_output], lock.for_transaction())
unsigned_tx = tx.serialize()
print('Raw unsigned transaction:', unsigned_tx)
# we need to rebuild the redeem script from the P2SH private key
# make the locking P2PKH address private key
sender_sk = PrivateKey(sender_priv_key)
# retrieve the public key of the locking address
sender_pk = sender_sk.get_public_key()
# rebuild the redeem script
redeem_script = Script([
seq.for_script(), 'OP_CHECKLOCKTIMEVERIFY', 'OP_DROP', 'OP_DUP',
'OP_HASH160',
sender_pk.get_address().to_hash160(), 'OP_EQUALVERIFY', 'OP_CHECKSIG'
])
# for every input of the transaction
for i, txin in enumerate(tx.inputs):
# create the signature for redeeming the funds
sig = sender_sk.sign_input(tx, i, redeem_script)
# and sign the input
txin.script_sig = Script(
[sig, sender_pk.to_hex(),
redeem_script.to_hex()])
signed_tx = tx.serialize()
print('Raw signed transaction:', signed_tx)
print('Transaction ID:', tx.get_txid())
# verify that the transaction is valid
ver = proxy.testmempoolaccept([signed_tx])
if ver[0]['allowed']:
# if the transaction is valid send the transaction to the blockchain
print('Transaction is valid.')
proxy.sendrawtransaction(signed_tx)
print('{} Bitcoin sent to address {}'.format(
Decimal(total_unspent) - Decimal(fee), rec_addr))
else:
# otherwise, display the reason the transaction failed
print('Transaction rejected. Reason:', ver[0]['reject-reason'])
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 as
# well as for an absolute amount of blocks or an absolute amount of seconds since the transaction.
#
parser = argparse.ArgumentParser(
description=
'Give the private key, a future time expressed either in block height or in UNIX Epoch time and '
'the P2SH address to send the funds')
parser.add_argument('key', help="Add the private key.")
parser.add_argument(
'-param',
type=int,
help="Add the number of blocks or the time expressed in seconds.")
parser.add_argument('-to_address',
type=str,
help="Add the adress that will sent/spend")
args = parser.parse_args()
# set values
key = args.key
absolute_param = args.param
send_address = args.to_address
# set Locktime
seq = Sequence(TYPE_ABSOLUTE_TIMELOCK, absolute_param)
locktime = Locktime(absolute_param)
# set proxy
username = "******"
password = "******"
proxy = NodeProxy(username, password).get_proxy()
# secret key corresponding to the pubkey needed for the P2SH (P2PKH) transaction
p2pkh_sk = PrivateKey(key)
p2pkh_pk = p2pkh_sk.get_public_key()
# get the address (from the public key)
p2pkh_addr = p2pkh_pk.get_address()
# print("Private key: " + p2pkh_sk. to_wif(compressed=True))
# print("Public key: " + p2pkh_pk.to_hex(compressed=True))
# print("P2PKH Address: " + p2pkh_addr.to_string())
# 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'
])
# accept a P2SH address to get the funds from
addr = P2shAddress.from_script(redeem_script)
print("The P2SH address to get the funds from is : " + addr.to_string())
# check if the P2SH address has any UTXOs to get funds from
proxy.importaddress(addr.to_string(), "P2SH to get the funds from")
minconf = 0
maxconf = 99999999
my_list = proxy.listunspent(minconf, maxconf, [addr.to_string()])
# Gather all funds that the P2SH address received to send to the P2PKH address provided
txin_list = []
btc_to_send = 0
for i in my_list:
txin = TxInput(i['txid'], i['vout'], sequence=seq.for_input_sequence())
txin_list.append(txin)
btc_to_send = btc_to_send + i['amount']
if btc_to_send == 0:
print("No btc found to send")
quit()
# accept a P2PKH address to send the funds to
to_addr = P2pkhAddress(send_address)
print("The P2PKH address to send the funds to is : " + to_addr.to_string())
# calculate the appropriate fees with respect to the size of the transaction
response = requests.get("https://mempool.space/api/v1/fees/recommended")
fee_per_byte = response.json()['fastestFee']
print("Fastest fee per byte is : %d " % fee_per_byte)
# calculate transaction size as described at
# https://bitcoin.stackexchange.com/questions/1195/how-to-calculate-transaction-size-before-sending-legacy-non-segwit-p2pkh-p2sh
tx_size = len(my_list) * 180 + 34 + 10 + len(my_list)
total_fees = tx_size * fee_per_byte / (1024 * 10**8)
print('Total fees are : ', total_fees)
# Calculate the final amount
amount = btc_to_send - total_fees
# print(amount)
# Create transaction output
txout = TxOutput(to_satoshis(amount), to_addr.to_script_pub_key())
# Create transaction after the inputs and the outputs
tx = Transaction(txin_list, [txout], locktime.for_transaction())
# For each transaction - when dealing with multiple inputs, you will need to sign all of them
for i, txin in enumerate(my_list):
sig = p2pkh_sk.sign_input(tx, i, 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.to_hex(),
redeem_script.to_hex()])
# display the raw signed transaction, ready to be broadcasted
signed_tx = tx.serialize()
print("\nRaw signed transaction:\n" + signed_tx)
# display the raw unsigned transaction
print("\nRaw unsigned transaction:\n" + tx.serialize())
# display the transaction id
print("\nTxId:", tx.get_txid())
# verify that the transaction is valid and will be accepted by the Bitcoin nodes
# if the transaction is valid, send it to the blockchain
is_valid = proxy.testmempoolaccept([signed_tx])
# print(is_valid)
if is_valid[0]['allowed']:
print("Transaction is valid!")
print("Sending transaction to blockchain..")
proxy.sendrawtransaction(signed_tx)
else:
print("Transaction not valid")
quit()
# # 9) display the raw signed transaction # if i: print( "raw signed transaction:\n" + tx.serialize() ) fee = int(tx.get_size() * satoshi_per_byte) # # 10) display the transaction id # print( " transaction id: " + tx.get_txid() ) # # 11) verify that the transaction is valid and will be accepted by the Bitcoin nodes # isvalid = proxy.testmempoolaccept( [tx.serialize()] )[0]['allowed'] print( "transaction valid: " + str(isvalid) ) # # 12) if the transaction is valid, send it to the blockchain # if isvalid:
amount = Decimal(btc_to_send) - Decimal(fee)
print("Amount:", amount)
txout = TxOutput(amount, to_address.to_script_pub_key())
# 15. Create the transaction using the input and output.
tx = Transaction([txin], [txout])
# 16. Sign the input.
sig = priv.sign_input(tx, 0, redeem_script)
# 17. Create the signature.
txin.script_sig = Script([sig, pub.to_hex(), redeem_script.to_hex()])
signed_tx = tx.serialize()
print("\nTxId:", tx.get_txid())
# 18. Print the raw transaction.
tx.get_txid()
tx.get_size()
tx
tx.has_segwit
# 19. Submit the transaction to the blockchain. What happens?
get_connection()
proxy.getrawmempool()
proxy.sendrawtransaction(signed_tx)
def __init__(self,
ft: Transaction,
id_l: Id,
id_r: Id,
val_l: float,
val_r: float,
fee: float,
timelockCT: int = consts.timelockCT):
self.ft = ft
self.id_l = id_l
self.id_r = id_r
self.fee = fee
self.timelockCT = timelockCT
self.timelock = consts.timelock
self.val_l = val_l
self.val_r = val_r
self.transactions = []
secret_rev = gen_secret()
ct_l = txs.get_standard_ct(TxInput(ft.get_txid(), 0),
id_l,
id_r,
hash256(secret_rev),
val_l,
val_r,
fee,
l=True,
timelock=0x2)
ct_script = ct_l.outputs[0].script_pubkey.script
ct_l_to_l = txs.get_standard_ct_spend(TxInput(ct_l.get_txid(),
0), id_l, ct_script,
val_l - 0.5 * self.fee, fee)
ct_l_punish = txs.get_standard_ct_punish(TxInput(ct_l.get_txid(),
0), self.id_r,
ct_script, secret_rev,
val_l - 0.5 * self.fee, fee)
self.transactions.append(('CT_l', ct_l))
self.transactions.append(('CT_l_to_l', ct_l_to_l))
self.transactions.append(
('CT_l_punish', ct_l_punish)
) # in the real world, this is added only when this state is revoked
secret_rev_r = gen_secret()
ct_r = txs.get_standard_ct(TxInput(ft.get_txid(), 0),
id_l,
id_r,
hash256(secret_rev_r),
val_l,
val_r,
fee,
l=False,
timelock=0x2)
ct_r_script = ct_r.outputs[0].script_pubkey.script
ct_r_to_r = txs.get_standard_ct_spend(TxInput(ct_r.get_txid(),
0), id_r, ct_r_script,
val_r - 0.5 * self.fee, fee)
ct_r_punish = txs.get_standard_ct_punish(TxInput(ct_r.get_txid(),
0), self.id_l,
ct_script, secret_rev_r,
val_r - 0.5 * self.fee, fee)
self.transactions.append(('CT_r', ct_l))
self.transactions.append(('CT_r_to_r', ct_r_to_r))
self.transactions.append(
('CT_r_punish', ct_r_punish)
) # in the real world, this is added only when this state is revoked
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(
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(
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())
txin.script_sig = Script([sign, p2pkh_pk, redeem_script.to_hex()])
# ***** Display the raw signed transaction
# Print Raw Signed Transaction
r_s_t = p2sh_out_tx.serialize()
print('\nRaw Signed Transaction: %s' %r_s_t)
# *** Display the transaction ID
# Signed Transaction ID
r_s_t_id = p2sh_out_tx.get_txid()
print('\nRaw Signed Transaction ID: %s' %r_s_t_id)
# ***** Verify that the transaction is valid and will be accepted by the Bitcoin nodes
def verify_tx(raw_signed_tx):
'''
This method verifies if a signed raw transaction would be accepted by mempool
by checking if the transaction violates the consensus or policy rules.
Arguments:
raw_signed_tx: the specific transaction (serialized, hex-encoded)
Returns:
system report
