def parse(cls, s):
amount = little_endian_to_int(4)
script_pub = Script.parse(s)
return cls(amount, script_pub)
from helper import decode_base58, little_endian_to_int, hash256, SIGHASH_ALL
from script import p2pkh_script, Script
from tx import TxIn, TxOut, Tx
from ecc import PrivateKey
# use 2 txin to send to mwJn1YPMq7y5F8J3LkC5Hxg9PHyZ5K4cFv
# our old private key
private_key = PrivateKey(little_endian_to_int(
hash256(b'dat_test_private_key')))
# some sats from a previous tx
prev_tx1 = bytes.fromhex(
'74699b8cc3dd67bdd54314283603c72b76a09368e5646b5b29c28028d5ae0076')
prev_index1 = 1
# sats from change of the tx of previous exercise
prev_tx2 = bytes.fromhex(
'47c0095c4e40c79128037c3861445c7f7d93e6ff9b55c10274395798f3503da8')
prev_index2 = 1
tx_in1 = TxIn(prev_tx1, prev_index1)
tx_in2 = TxIn(prev_tx2, prev_index2)
# where we send our sats
tx_outs = []
target_amount = 200000
from helper import decode_base58, little_endian_to_int, hash256, SIGHASH_ALL, hash160, h160_to_p2sh_address
from script import p2pkh_script, p2sh_script, Script
from tx import TxIn, TxOut, Tx
from ecc import PrivateKey
# we send to a p2sh address
secret1 = little_endian_to_int(hash256(b'dat_test_private_key_p2sh1'))
secret2 = little_endian_to_int(hash256(b'dat_test_private_key2_p2sh2'))
private_key1 = PrivateKey(secret1)
private_key2 = PrivateKey(secret2)
print(private_key1.point.address(
testnet=True)) #mfchv5Xq63UuQTAVwzqhWVHAZVkiZrhDKh
print(private_key2.point.address(
testnet=True)) #ms4kdy8Hn4WfxK2J2VpbonTit5NeNy6vJS
## first we create the scriptPubKey of the redeemscript or redeem script
# we decode our previous pubkey to put them in script commands
public_key1 = decode_base58('mfchv5Xq63UuQTAVwzqhWVHAZVkiZrhDKh')
public_key2 = decode_base58('ms4kdy8Hn4WfxK2J2VpbonTit5NeNy6vJS')
#redeem script as op code
dat_redeem_script_op = Script([0x52, public_key1, public_key2, 0x52, 0xae])
print('dat_redeem_script_op:{}'.format(dat_redeem_script_op))
def target(self):
exponent = self.bits[-1]
coefficient = little_endian_to_int(self.bits[:-1])
return coefficient * 256**(exponent - 3)
print("Amount available to spend (after fees): " +str(amount_available/sat_in_bit) + " tBTC")
''' Construct Outputs '''
tx_outs = []
num_outputs= int(input("How many outputs (NOT including the output for left-over change)? "))
tx_outs = get_output_info(num_outputs, amount_available)
''' Construct Transaction object '''
tx_obj = Tx(1, tx_ins, tx_outs, 0, True)
''' Signing the inputs '''
for i in range(len(tx_ins)):
print("Enter your private key passphrase to prove that you can sign input "+str(i)+":")
password = getpass.getpass('Passphrase:')
private_key = PrivateKey(little_endian_to_int(hash256(str.encode(password))))
tx_obj.sign_input(i, private_key)
if(tx_obj.verify()):
print("-------Transaction Successfully Signed-------")
print("===>raw transaction:")
tx_serial = tx_obj.serialize().hex()
print(tx_serial)
#p.sendrawtransaction(tx_serial)
#print("===>transaction successfully published<====")
print("==> use this with 'bitcoin-cli sendrawtransaction <raw_tx>' in order to broadcast it")
else:
print("Incorrect Signature for this Transaction")
def parse(cls, s):
amount = little_endian_to_int(s.read(8))
script_pubkey = Script.parse(s)
return cls(amount, script_pubkey)
def test_example_2(self):
bits = bytes.fromhex('e93c0118')
exponent = bits[-1]
coefficient = little_endian_to_int(bits[:-1])
target = coefficient * 256**(exponent - 3)
self.assertEqual('{:x}'.format(target).zfill(64), '0000000000000000013ce9000000000000000000000000000000000000000000')
def create_btc_address(passphrase):
secret = little_endian_to_int(hash256(passphrase))
publicKey = PrivateKey(secret).point
print(publicKey.sec())
address = publicKey.address(testnet=True)
return address
def parse(cls, s):
txo = TXO.parse(s)
spending_tx_id = s.read(32)
spending_tx_index = little_endian_to_int(s.read(4))
return cls(txo, spending_tx_id, spending_tx_index)
def test_broadcast(self):
from bloomfilter import BloomFilter
last_block_hex = '00000000000000a03f9432ac63813c6710bfe41712ac5ef6faab093fe2917636'
secret = little_endian_to_int(hash256(b'Jimmy Song'))
private_key = PrivateKey(secret=secret)
h160 = private_key.point.hash160()
addr = private_key.point.address(testnet=True)
target_address = 'mwJn1YPMq7y5F8J3LkC5Hxg9PHyZ5K4cFv'
target_h160 = decode_base58(target_address)
target_script = p2pkh_script(target_h160)
fee = 5000 # fee in satoshis
# connect to programmingblockchain.com in testnet mode
node = SimpleNode('programmingblockchain.com', testnet=True)
# create a bloom filter of size 30 and 5 functions. Add a tweak.
bf = BloomFilter(30, 5, 90210)
# add the h160 to the bloom filter
bf.add(h160)
# load the bloom filter with the filterload command
node.send(bf.filterload())
# set start block to last_block from above
start_block = bytes.fromhex(last_block_hex)
# send a getheaders message with the starting block
getheaders = GetHeadersMessage(start_block=start_block)
node.send(getheaders)
# wait for the headers message
headers = node.wait_for(HeadersMessage)
block_hashes = [b.hash() for b in headers.blocks]
# initialize prev_tx, prev_index and prev_amount to None
prev_tx, prev_index, prev_amount = None, None, None
for h, tx_obj in node.get_filtered_block_txs(block_hashes):
self.assertEqual(h, tx_obj.hash())
tx_obj.testnet = True
# loop through the tx outs
for i, tx_out in enumerate(tx_obj.tx_outs):
# if our output has the same address as our address we found it
if tx_out.script_pubkey.address(testnet=True) == addr:
# we found our utxo. set prev_tx, prev_index, and tx
prev_tx = h
prev_index = i
prev_amount = tx_out.amount
self.assertEqual(
h.hex(),
'b2cddd41d18d00910f88c31aa58c6816a190b8fc30fe7c665e1cd2ec60efdf3f'
)
self.assertEqual(i, 7)
break
if prev_tx:
break
# create the TxIn
tx_in = TxIn(prev_tx, prev_index)
# calculate the output amount (previous amount minus the fee)
output_amount = prev_amount - fee
# create a new TxOut to the target script with the output amount
tx_out = TxOut(output_amount, target_script)
# create a new transaction with the one input and one output
tx_obj = Tx(1, [tx_in], [tx_out], 0, testnet=True)
# sign the only input of the transaction
self.assertTrue(tx_obj.sign_input_p2pkh(0, private_key))
# serialize and hex to see what it looks like
want = '01000000013fdfef60ecd21c5e667cfe30fcb890a116688ca51ac3880f91008dd141ddcdb2070000006b483045022100ff77d2559261df5490ed00d231099c4b8ea867e6ccfe8e3e6d077313ed4f1428022033a1db8d69eb0dc376f89684d1ed1be75719888090388a16f1e8eedeb8067768012103dc585d46cfca73f3a75ba1ef0c5756a21c1924587480700c6eb64e3f75d22083ffffffff019334e500000000001976a914ad346f8eb57dee9a37981716e498120ae80e44f788ac00000000'
self.assertEqual(tx_obj.serialize().hex(), want)
# send this signed transaction on the network
node.send_tx(tx_obj)
from ecc import PrivateKey from helper import hash256, little_endian_to_int passphrase = b'jiboiamutante' secret = little_endian_to_int(hash256(passphrase)) priv = PrivateKey(secret) print(priv.point.address(testnet = True)) '''Address: mkHc2s6q11EqgwLGdg9Adh6qM7C6yUfXqv'''
def bits_to_target(bits):
exponent = bits[-1]
coefficient = little_endian_to_int(bits[:-1])
return coefficient * 256**(exponent - 3)
def coinbase_height(self):
if not self.is_coinbase():
return None
element = self.tx_ins[0].script_sig.instructions[0]
return little_endian_to_int(element)
def coinbase_height(self):
if self.is_coinbase():
return little_endian_to_int(self.tx_ins[0].script_sig.cmds[0])
else:
return None
def tx_in_parse(cls, s):
prev_tx = s.read(32)[::-1]
prev_index = little_endian_to_int(s.read(4))
script_sig = Script.parse(s)
sequence = little_endian_to_int(s.read(4))
return cls(prev_tx, prev_index, script_sig, sequence)
def __init__(self, passphrase):
self.secret = little_endian_to_int(hash256(passphrase))
self.private_key = PrivateKey(self.secret)
self.public_key = self.private_key.point
self.address = self.public_key.address(testnet=True)
def bits_to_target(self):
exponent = self.bits[-1]
coefficient = little_endian_to_int(self.bits[:-1])
target = coefficient * pow(256, exponent - 3)
return target
def H(*args):
return little_endian_to_int(H_(*args))
def check_pow(self):
h256 = hash256(self.serialize())
work = little_endian_to_int(h256)
return work < self.target()
def coinbase_height(self):
if not is_coinbase(self):
return None
return little_endian_to_int(self.tx_ins[0].script_sig.commands[0])
from helper import decode_base58, little_endian_to_int, hash256, SIGHASH_ALL, hash160, h160_to_p2sh_address
from script import p2pkh_script, Script
from tx import TxIn, TxOut, Tx
from ecc import PrivateKey
# -- try of a 2 of 2 musig p2sh --
# 2 private key because 2 of 2
secret1 = little_endian_to_int(hash256(b'dat_test_private_key_p2sh1'))
secret2 = little_endian_to_int(hash256(b'dat_test_private_key2_p2sh2'))
# derived pubkeys
private_key1 = PrivateKey(secret1)
private_key2 = PrivateKey(secret2)
print(private_key1.point.address(testnet=True))
print(private_key2.point.address(testnet=True))
## first we create the scriptPubKey of the redeemscript or redeem script
# we decode our previous pubkey to put them in script commands
public_key1 = decode_base58('mvEg6eZ3sUApodedYQrkpEPMMALsr1K1k1')
public_key2 = decode_base58('mwjg9Y1jeFdNu7DQBAW7DUbJqj6jMmhd74')
#dat_redeem_script_t1 = 0x52, public_key1, public_key2, 0x52, 0xae
def parse(cls, s):
# get the length of the entire field
#print(s)
length = read_varint(s)
#print(f"length script: {length}")
# initialize the cmds array
cmds = []
# initialize the number of bytes we've read to 0
count = 0
# loop until we've read length bytes
while count < length:
# get the current byte
#print(f"WHILE: count {count} and length {length}")
current = s.read(1)
# increment the bytes we've read
count += 1
# convert the current byte to an integer
current_byte = current[0]
#print(f"current_byte : {current_byte}")
# if the current byte is between 1 and 75 inclusive
if current_byte >= 1 and current_byte <= 75:
# we have an cmd set n to be the current byte
n = current_byte
# add the next n bytes as an cmd
cmds.append(s.read(n))
# increase the count by n
count += n
elif current_byte == 76:
# op_pushdata1
data_length = little_endian_to_int(s.read(1))
if (data_length + count) > length:
print(
f"BAD SCRIPT: original script data_length {data_length} "
)
data_length = length - count - 1
print(f"Fixed script data_length to {data_length }")
s.read(data_length)
raise SyntaxError('parsing script failed')
cmds.append(s.read(data_length))
count += data_length + 1
elif current_byte == 77:
# op_pushdata2
data_length = little_endian_to_int(s.read(2))
if (data_length + count) > length:
print(
f"BAD SCRIPT: original script data_length {data_length} "
)
data_length = length - count - 2
print(f"Fixed script data_length to {data_length}")
s.read(data_length)
raise SyntaxError('parsing script failed')
cmds.append(s.read(data_length))
count += data_length + 2
else:
# we have an opcode. set the current byte to op_code
op_code = current_byte
#print(f"op_code : {op_code}")
# add the op_code to the list of cmds
cmds.append(op_code)
if count != length:
raise SyntaxError('parsing script failed')
return cls(cmds)
def parse(cls, s):
type_ = little_endian_to_int(s.read(4))
hash_ = s.read(32)
return cls(type_, hash_)
def coinbase_height(self):
if not self.is_coinbase():
return None
first_input = self.tx_ins[0]
first_element = first_input.script_sig.commands[0]
return little_endian_to_int(first_element)
from ecc import PrivateKey
from helper import hash256, little_endian_to_int, decode_base58, SIGHASH_ALL
from script import p2pkh_script, Script
from tx import TxIn, TxOut, Tx
secret = little_endian_to_int(hash256(b'my first secret key'))
private_key = PrivateKey(secret)
print(private_key.point.address(testnet=True))
prev_tx = bytes.fromhex(
'6e7657754799fe7a906b213aa57b6920ad2d660f349fcb52dd384568aaddc2ef')
prev_index = 1
tx_in = TxIn(prev_tx, prev_index)
tx_outs = []
change_amount = int(0.004 * 10000000)
change_h160 = decode_base58('mxUJg9m1dsqpHnbhV15mwJ3GjwPBVMHVmu')
change_script = p2pkh_script(change_h160)
change_output = TxOut(change_amount, change_script)
target_amount = int(0.007 * 10000000)
target_h160 = decode_base58('mwJn1YPMq7y5F8J3LkC5Hxg9PHyZ5K4cFv')
target_script = p2pkh_script(target_h160)
target_output = TxOut(target_amount, target_script)
tx_obj = Tx(1, [tx_in], [change_output, target_output], 0, True)
print(tx_obj.sign_input(0, private_key))
print(tx_obj.serialize().hex())
def check_pow(self):
h256 = hash256(self.serialize())
proof = little_endian_to_int(h256)
return proof < self.target()
def test_exercise_8(self):
passphrase = b'Jimmy Song Programming Blockchain'
secret = little_endian_to_int(hash256(passphrase))
point = secret * G
self.assertEqual(point.address(testnet=True),
'mwJn1YPMq7y5F8J3LkC5Hxg9PHyZ5K4cFv')
