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