def test_sign_input(self): private_key = PrivateKey(secret=8675309) stream = BytesIO( bytes.fromhex( '010000000199a24308080ab26e6fb65c4eccfadf76749bb5bfa8cb08f291320b3c21e56f0d0d00000000ffffffff02408af701000000001976a914d52ad7ca9b3d096a38e752c2018e6fbc40cdf26f88ac80969800000000001976a914507b27411ccf7f16f10297de6cef3f291623eddf88ac00000000' )) tx_obj = Tx.parse(stream, testnet=True) self.assertTrue(tx_obj.sign_input(0, private_key)) want = '010000000199a24308080ab26e6fb65c4eccfadf76749bb5bfa8cb08f291320b3c21e56f0d0d0000006b4830450221008ed46aa2cf12d6d81065bfabe903670165b538f65ee9a3385e6327d80c66d3b502203124f804410527497329ec4715e18558082d489b218677bd029e7fa306a72236012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff02408af701000000001976a914d52ad7ca9b3d096a38e752c2018e6fbc40cdf26f88ac80969800000000001976a914507b27411ccf7f16f10297de6cef3f291623eddf88ac00000000' self.assertEqual(tx_obj.serialize().hex(), want)
def test_address_2(self): secrets = (b'[email protected] test1', b'[email protected] test2') private_keys = [ PrivateKey(little_endian_to_int(hash256(s))) for s in secrets ] points = [p.point for p in private_keys] redeem_script = multisig_redeem_script(2, points) h160 = redeem_script.hash160() script_pubkey = p2sh_script(h160) self.assertEqual(script_pubkey.address(testnet=True), '2MxEZNps15dAnGX5XaVwZWgoDvjvsDE5XSx')
def from_seed(cls, seed, path): raw = HMAC(key=b'Bitcoin seed', msg=seed, digestmod=sha512).digest() private_key = PrivateKey(secret=int.from_bytes(raw[:32], 'big')) chain_code = raw[32:] root = cls( private_key=private_key, chain_code=chain_code, depth=0, fingerprint=b'\x00\x00\x00\x00', child_number=0, ) return root.traverse(path)
def from_seed(cls, seed, testnet=False): # get hmac_sha512 with b'Bitcoin seed' and seed h = hmac_sha512(b'Bitcoin seed', seed) # create the private key using the first 32 bytes in big endian private_key = PrivateKey(secret=big_endian_to_int(h[:32])) # chaincode is the last 32 bytes chain_code = h[32:] # return an instance of the class return cls( private_key=private_key, chain_code=chain_code, testnet=testnet, )
def test_sign_input(self): private_key = PrivateKey(secret=8675309) tx_ins = [] prev_tx = bytes.fromhex('0025bc3c0fa8b7eb55b9437fdbd016870d18e0df0ace7bc9864efc38414147c8') tx_ins.append(TxIn(prev_tx, 0)) tx_outs = [] h160 = decode_base58('mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2') tx_outs.append(TxOut(amount=int(0.99 * 100000000), script_pubkey=p2pkh_script(h160))) h160 = decode_base58('mnrVtF8DWjMu839VW3rBfgYaAfKk8983Xf') tx_outs.append(TxOut(amount=int(0.1 * 100000000), script_pubkey=p2pkh_script(h160))) tx = Tx(1, tx_ins, tx_outs, 0, testnet=True) self.assertTrue(tx.sign_input(0, private_key))
def test_example_6(self): tx_ins = [] prev_tx = bytes.fromhex('0d6fe5213c0b3291f208cba8bfb59b7476dffacc4e5cb66f6eb20a080843a299') prev_index = 13 tx_ins.append(TxIn(prev_tx, prev_index, Script([]), 0xffffffff)) tx_outs = [] change_amount = int(0.33 * 100000000) change_h160 = decode_base58('mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2') change_script = p2pkh_script(change_h160) tx_outs.append(TxOut(amount=change_amount, script_pubkey=change_script)) target_amount = int(0.1 * 100000000) target_h160 = decode_base58('mnrVtF8DWjMu839VW3rBfgYaAfKk8983Xf') target_script = p2pkh_script(target_h160) tx_outs.append(TxOut(amount=target_amount, script_pubkey=target_script)) transaction = Tx(1, tx_ins, tx_outs, 0, testnet=True) z = transaction.sig_hash(0) private_key = PrivateKey(secret=8675309) der = private_key.sign(z).der() sig = der + SIGHASH_ALL.to_bytes(1, 'big') sec = private_key.point.sec() transaction.tx_ins[0].script_sig = Script([sig, sec]) want = '010000000199a24308080ab26e6fb65c4eccfadf76749bb5bfa8cb08f291320b3c21e56f0d0d0000006b4830450221008ed46aa2cf12d6d81065bfabe903670165b538f65ee9a3385e6327d80c66d3b502203124f804410527497329ec4715e18558082d489b218677bd029e7fa306a72236012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff02408af701000000001976a914d52ad7ca9b3d096a38e752c2018e6fbc40cdf26f88ac80969800000000001976a914507b27411ccf7f16f10297de6cef3f291623eddf88ac00000000' self.assertEqual(transaction.serialize().hex(), want)
def changewallet(privkey_wif): priv = PrivateKey(privkey_wif) sec = str(priv.secret) print("sec") print(sec) print(len(sec)) x = str(int(str(priv.point.x), 16)) print("x") print(x) y = str(int(str(priv.point.y), 16)) print("y") print(y) ardubridge.writewallet(sec) ardubridge.writepubkey(x, y)
def test_address_p2wsh(self): secrets = (b'[email protected] test1', b'[email protected] test2') private_keys = [ PrivateKey(little_endian_to_int(hash256(s))) for s in secrets ] points = [p.point for p in private_keys] witness_script = multisig_redeem_script(2, points) h256 = witness_script.sha256() script_pubkey = p2wsh_script(h256) addr = script_pubkey.address(testnet=True) self.assertEqual( addr, 'tb1qevl98yey2nqnhnh5psn3h73zfl9yy5ae3ss4e79qungqa8y0eprsl8gle6')
def test_address_p2sh_p2wsh(self): secrets = (b'[email protected] test1', b'[email protected] test2') private_keys = [ PrivateKey(little_endian_to_int(hash256(s))) for s in secrets ] points = [p.point for p in private_keys] witness_script = multisig_redeem_script(2, points) h256 = witness_script.sha256() redeem_script = p2wsh_script(h256) h160 = redeem_script.hash160() script_pubkey = p2sh_script(h160) self.assertEqual(script_pubkey.address(testnet=True), '2MuVPpBuS6evYsVeUJ85Z5Z6hokXGdtkYAw')
def test_sign_p2wpkh(self): private_key = PrivateKey(secret=8675309) prev_tx = bytes.fromhex( '6bfa079532dd9fad6cfbf218edc294fdfa7dd0cb3956375bc864577fb36fad97') prev_index = 0 fee = 500 tx_in = TxIn(prev_tx, prev_index) amount = tx_in.value(testnet=True) - fee h160 = decode_base58('mqYz6JpuKukHzPg94y4XNDdPCEJrNkLQcv') tx_out = TxOut(amount=amount, script_pubkey=P2PKHScriptPubKey(h160)) t = Tx(1, [tx_in], [tx_out], 0, testnet=True, segwit=True) self.assertTrue(t.sign_input(0, private_key)) want = '0100000000010197ad6fb37f5764c85b375639cbd07dfafd94c2ed18f2fb6cad9fdd329507fa6b0000000000ffffffff014c400f00000000001976a9146e13971913b9aa89659a9f53d327baa8826f2d7588ac02483045022100feab5b8feefd5e774bdfdc1dc23525b40f1ffaa25a376f8453158614f00fa6cb02204456493d0bc606ebeb3fa008e056bbc96a67cb0c11abcc871bfc2bec60206bf0012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b6700000000' self.assertEqual(t.serialize().hex(), want)
def test_sign_p2sh_p2wpkh(self): private_key = PrivateKey(secret=8675309) redeem_script = private_key.point.p2sh_p2wpkh_redeem_script() prev_tx = bytes.fromhex( '2e19b463bd5c8a3e0f10ae827f5a670f6794fca96394ecf8488321291d1c2ee9') prev_index = 1 fee = 500 tx_in = TxIn(prev_tx, prev_index) amount = tx_in.value(testnet=True) - fee h160 = decode_base58('mqYz6JpuKukHzPg94y4XNDdPCEJrNkLQcv') tx_out = TxOut(amount=amount, script_pubkey=P2PKHScriptPubKey(h160)) t = Tx(1, [tx_in], [tx_out], 0, testnet=True, segwit=True) self.assertTrue( t.sign_input(0, private_key, redeem_script=redeem_script)) want = '01000000000101e92e1c1d29218348f8ec9463a9fc94670f675a7f82ae100f3e8a5cbd63b4192e0100000017160014d52ad7ca9b3d096a38e752c2018e6fbc40cdf26fffffffff014c400f00000000001976a9146e13971913b9aa89659a9f53d327baa8826f2d7588ac0247304402205e3ae5ac9a0e0a16ae04b0678c5732973ce31051ba9f42193e69843e600d84f2022060a91cbd48899b1bf5d1ffb7532f69ab74bc1701a253a415196b38feb599163b012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b6700000000' self.assertEqual(t.serialize().hex(), want)
def spend_tx(cls, wifs, utxos, destination_addr, fee=540): destination_address_data = cls.get_address_data(destination_addr) testnet = destination_address_data['testnet'] if testnet: prefix = bytes([cls.testnet_prefixes[0]]) else: prefix = bytes([cls.p2pkh_prefixes[0]]) tx_ins = [] sequence = 0xffffffff priv_lookup = {} total = 0 for wif in wifs: priv_key = PrivateKey.parse(wif) addr = priv_key.point.address(priv_key.compressed, prefix=prefix) # look up utxos for each address address_data = cls.get_address_data(addr) script_pubkey = address_data['script_pubkey'] spk = script_pubkey.serialize() priv_lookup[spk] = priv_key if not utxos: raise RuntimeError('fetch utxos first') for serialized_script_pubkey, prev_tx, prev_index, value in utxos: tx_ins.append( TxIn(prev_tx, prev_index, b'', sequence, value=value, script_pubkey=serialized_script_pubkey)) total += value num_tx_ins = len(tx_ins) if num_tx_ins == 0: raise RuntimeError('nothing to spend') script_pubkey = destination_address_data['script_pubkey'] tx_out = TxOut(total - fee, script_pubkey.serialize()) tx = cls(cls.default_version, tx_ins, [tx_out], 0, testnet=testnet) for index, tx_in in enumerate(tx_ins): priv_key = priv_lookup[tx_in.script_pubkey().serialize()] tx.sign_input( index, priv_key, cls.default_hash_type, compressed=priv_key.compressed, ) if not tx.verify(): raise RuntimeError('failed validation') return tx.serialize()
def schnorr(): pk = PrivateKey(randint(0, 2**256)) point = pk.point # public point def sign(pk, z): k = randint(0, 2**256) # nonce R = k * ecc.G # nonce point s = (k + HI(R.sec(), z) * pk.secret) % ecc.N return R, s def verify(R, s, z): Q = s * ecc.G - HI(R.sec(), z) * point return Q == R z = gen_msg() R, s = sign(pk, z) assert verify(R, s, z)
def child(self, index): if index >= 0x80000000: raise ValueError('child number should always be less than 2^31') sec = self.point.sec() data = sec + index.to_bytes(4, 'big') raw = HMAC(key=self.chain_code, msg=data, digestmod=sha512).digest() point = PrivateKey(int.from_bytes(raw[:32], 'big')).point + self.point chain_code = raw[32:] depth = self.depth + 1 fingerprint = hash160(sec)[:4] child_number = index return HDPublicKey( point=point, chain_code=chain_code, depth=depth, fingerprint=fingerprint, child_number=child_number, )
def xprv_child(self, index): if index >= 0x80000000: data = int_to_big_endian(self.private_key.secret, 33) + int_to_big_endian(index, 4) else: data = self.private_key.point.sec() + int_to_big_endian(index, 4) h = hmac_sha512(self.chain_code, data) secret = (big_endian_to_int(h[:32]) + self.private_key.secret) % N private_key = PrivateKey(secret=secret) chain_code = h[32:] depth = self.depth + 1 parent_fingerprint = self.pub.hash160()[:4] child_number = index return HDPrivateKey( private_key=private_key, chain_code=chain_code, depth=depth, parent_fingerprint=parent_fingerprint, child_number=child_number, testnet=self.testnet, )
def test_exercise_3_1(self): prev_tx = bytes.fromhex( 'eb581753a4dbd6befeaaaa28a6f4576698ba13a07c03da693a65bce11cf9887a') prev_index = 1 target_address = 'mwJn1YPMq7y5F8J3LkC5Hxg9PHyZ5K4cFv' target_amount = 0.04 change_address = 'mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2' fee = 50000 secret = 8675309 private_key = PrivateKey(secret=secret) tx_ins = [] tx_ins.append(TxIn(prev_tx, prev_index)) tx_outs = [] h160 = decode_base58(target_address) script_pubkey = p2pkh_script(h160) target_satoshis = int(target_amount * 100000000) tx_outs.append(TxOut(target_satoshis, script_pubkey)) h160 = decode_base58(change_address) script_pubkey = p2pkh_script(h160) prev_amount = tx_ins[0].value(testnet=True) change_satoshis = prev_amount - target_satoshis - fee tx_outs.append(TxOut(change_satoshis, script_pubkey)) tx_obj = Tx(1, tx_ins, tx_outs, 0, testnet=True) tx_obj.sign_input(0, private_key) if private_key.point.address(testnet=True) != change_address: raise RuntimeError( 'Private Key does not correspond to Change Address, check priv_key and change_address' ) if tx_ins[0].script_pubkey( testnet=True).instructions[2] != decode_base58(change_address): raise RuntimeError( 'Output is not something you can spend with this private key. Check that the prev_tx and prev_index are correct' ) if tx_obj.fee() > 0.05 * 100000000 or tx_obj.fee() <= 0: raise RuntimeError( 'Check that the change amount is reasonable. Fee is {}'.format( tx_obj.fee())) self.assertEqual( tx_obj.serialize().hex(), '01000000017a88f91ce1bc653a69da037ca013ba986657f4a628aaaafebed6dba4531758eb010000006a47304402204ce6e3877ed2e18d2165276cbdba241507ce72b44d8df640eb6cb4d415eaaea002207dffd162da35593d86188ce87a1cbc9d3a5b26391870f19bf1764ca05b315ad9012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff0200093d00000000001976a914ad346f8eb57dee9a37981716e498120ae80e44f788ac7077e401000000001976a914d52ad7ca9b3d096a38e752c2018e6fbc40cdf26f88ac00000000' )
def parse(cls, s): raw = raw_decode_base58(s.read(111), num_bytes=82) version = raw[:4] if version in (TESTNET_XPRV, TESTNET_YPRV, TESTNET_ZPRV): testnet = True elif version in (MAINNET_XPRV, MAINNET_YPRV, MAINNET_ZPRV): testnet = False else: raise ValueError('not an xprv, yprv or zprv: {}'.format(version)) depth = raw[4] fingerprint = raw[5:9] child_number = int.from_bytes(raw[9:13], 'big') chain_code = raw[13:45] private_key = PrivateKey(secret=int.from_bytes(raw[46:], 'big')) return cls( private_key=private_key, chain_code=chain_code, depth=depth, fingerprint=fingerprint, child_number=child_number, testnet=testnet, )
def Mu(Ns=10): pks = [PrivateKey(randint(0, 2**256)) for _ in range(Ns)] points = [pk.point for pk in pks] def sign(pks, z): L = H(*[p.sec() for p in points]) ks = [randint(0, 2**256) for _ in range(len(pks))] Rs = [k * ecc.G for k in ks] R = sum(Rs, ecc.S256Point(None, None)) # aggregate key P = sum((HI(L, p.sec()) * p for p in points), ecc.S256Point(None, None)) cs = [HI(R.sec(), z) * HI(L, p.sec()) for p in points] s = sum([k + c * pk.secret for k, c, pk in zip(ks, cs, pks)]) % ecc.N return R, s, P def verify(R, s, z, P): return R == s * ecc.G - HI(R.sec(), z) * P z = gen_msg() R, s, P = sign(pks, z) assert verify(R, s, z, P)
def test_b2x_sign(self): # Generated from ./bitcoin2x-qt -regtest wif = 'cVC6z7gnezHZut5yyuCX3x79tfcbauCWiFcBY92Vg4crfu4Maa5B' prev_tx = 'b6d073333c1a8e4360b1e2c7fa2ed6b67b74272ad7fabf52a4e4732df5f47dbd' prev_index = 0 prev_value = 5000000000 destination = 'mrVqpGm7F5MVCwsP4s3fQEN2GAaykJoTu4' amount = 4996000000 priv_key = PrivateKey.parse(wif) prev_script_pubkey = B2XTx.get_address_data( priv_key.point.address())['script_pubkey'].serialize() tx_in = TxIn(unhexlify(prev_tx), prev_index, b'', 0xffffffff, b'\x00', prev_value, prev_script_pubkey) script = B2XTx.get_address_data( destination)['script_pubkey'].serialize() tx_out = TxOut(amount, script) tx = B2XTx(2, [tx_in], [tx_out], 0, testnet=True) tx.sign(priv_key) want = "0200000001bd7df4f52d73e4a452bffad72a27747bb6d62efac7e2b160438e1a3c3373d0b6000000006a47304402201df7c8c97443bd46da751e0051a4395ba3613be3604be97d3c801c21e3d23c79022012ad30b7ffd42ad7bb96f9157519f7e3c35409ed54f783a3c854a596343a6c713121030f96812693c4a50162134cfa307afb63580171963d6c4198e8e5cfeee2c92b60ffffffff0100e9c829010000001976a91478738f2c5a75397eb2f851597261f766a67d9b6388ac00000000" self.assertTrue(tx.verify()) self.assertEqual(tx.serialize().hex(), want)
def parse(cls, xprv): raw = decode_base58(xprv, num_bytes=82) version = raw[:4] if version == unhexlify('04358394'): testnet = True elif version == unhexlify('0488ADE4'): testnet = False else: raise RuntimeError('not an xprv: {}'.format(xprv)) depth = raw[4] fingerprint = raw[5:9] child_number = int.from_bytes(raw[9:13], 'big') chain_code = raw[13:45] private_key = PrivateKey(secret=int.from_bytes(raw[46:], 'big')) return cls( private_key=private_key, chain_code=chain_code, depth=depth, fingerprint=fingerprint, child_number=child_number, testnet=testnet, )
def child(self, index): '''Returns the child HDPrivateKey at a particular index. Hardened children return for indices >= 0x8000000. ''' # if index >= 0x80000000 if index >= 0x80000000: # the message data is the private key secret in 33 bytes in # big-endian and the index in 4 bytes big-endian. data = int_to_big_endian(self.private_key.secret, 33) + int_to_big_endian(index, 4) else: # the message data is the public key compressed SEC # and the index in 4 bytes big-endian. data = self.private_key.point.sec() + int_to_big_endian(index, 4) # get the hmac_sha512 with chain code and data h = hmac_sha512(self.chain_code, data) # the new secret is the first 32 bytes as a big-endian integer # plus the secret mod N secret = (big_endian_to_int(h[:32]) + self.private_key.secret) % N # create the PrivateKey object private_key = PrivateKey(secret=secret) # the chain code is the last 32 bytes chain_code = h[32:] # depth is whatever the current depth + 1 depth = self.depth + 1 # parent_fingerprint is the fingerprint of this node parent_fingerprint = self.fingerprint() # child number is the index child_number = index # return a new HDPrivateKey instance return HDPrivateKey( private_key=private_key, chain_code=chain_code, depth=depth, parent_fingerprint=parent_fingerprint, child_number=child_number, testnet=self.testnet, )
def test_exercise_5(self): prev_tx_1 = bytes.fromhex('11d05ce707c1120248370d1cbf5561d22c4f83aeba0436792c82e0bd57fe2a2f') prev_index_1 = 1 prev_tx_2 = bytes.fromhex('51f61f77bd061b9a0da60d4bedaaf1b1fad0c11e65fdc744797ee22d20b03d15') prev_index_2 = 1 target_address = 'mwJn1YPMq7y5F8J3LkC5Hxg9PHyZ5K4cFv' target_amount = 0.0429 secret = 8675309 priv = PrivateKey(secret=secret) tx_ins = [] tx_ins.append(TxIn(prev_tx_1, prev_index_1, Script([]), 0xffffffff)) tx_ins.append(TxIn(prev_tx_2, prev_index_2, Script([]), 0xffffffff)) tx_outs = [] h160 = decode_base58(target_address) script_pubkey = p2pkh_script(h160) target_satoshis = int(target_amount * 100000000) tx_outs.append(TxOut(target_satoshis, script_pubkey)) tx_obj = Tx(1, tx_ins, tx_outs, 0, testnet=True) self.assertTrue(tx_obj.sign_input(0, priv)) self.assertTrue(tx_obj.sign_input(1, priv)) self.assertTrue(tx_obj.verify()) want = '01000000022f2afe57bde0822c793604baae834f2cd26155bf1c0d37480212c107e75cd011010000006a47304402204cc5fe11b2b025f8fc9f6073b5e3942883bbba266b71751068badeb8f11f0364022070178363f5dea4149581a4b9b9dbad91ec1fd990e3fa14f9de3ccb421fa5b269012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff153db0202de27e7944c7fd651ec1d0fab1f1aaed4b0da60d9a1b06bd771ff651010000006b483045022100b7a938d4679aa7271f0d32d83b61a85eb0180cf1261d44feaad23dfd9799dafb02205ff2f366ddd9555f7146861a8298b7636be8b292090a224c5dc84268480d8be1012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff01d0754100000000001976a914ad346f8eb57dee9a37981716e498120ae80e44f788ac00000000' self.assertEqual(tx_obj.serialize().hex(), want)
def BN(Ns=10): # num sig pks = [PrivateKey(randint(0, 2**256)) for _ in range(Ns)] points = [pk.point for pk in pks] def sign(pks, z): ks = [randint(0, 2**256) for _ in range(len(pks))] L = H(*[p.sec() for p in points]) Rs = [k * ecc.G for k in ks] R = sum(Rs, ecc.S256Point(None, None)) cs = [HI(L, p.sec(), R.sec(), z) for p in points] s = sum(k + c * pk.secret for k, c, pk in zip(ks, cs, pks)) % ecc.N return R, s def verify(R, s, z): L = H(*[p.sec() for p in points]) cs = [HI(L, p.sec(), R.sec(), z) for p in points] return R == s * ecc.G - sum( (c * p for c, p in zip(cs, points)), ecc.S256Point(None, None)) z = gen_msg() R, s = sign(pks, z) assert verify(R, s, z)
def xprv_raw_parse(cls, s): version = s.read(4) if version in (TESTNET_XPRV, TESTNET_YPRV, TESTNET_ZPRV): testnet = True elif version in (MAINNET_XPRV, MAINNET_YPRV, MAINNET_ZPRV): testnet = False else: raise ValueError('not an xprv, yprv or zprv: {}'.format(version)) depth = byte_to_int(s.read(1)) parent_fingerprint = s.read(4) child_number = big_endian_to_int(s.read(4)) chain_code = s.read(32) if byte_to_int(s.read(1)) != 0: raise ValueError('private key should be preceded by a zero byte') private_key = PrivateKey(secret=big_endian_to_int(s.read(32))) return cls( private_key=private_key, chain_code=chain_code, depth=depth, parent_fingerprint=parent_fingerprint, child_number=child_number, testnet=testnet, )
def test_sign_input(self): private_key = PrivateKey(secret=8675309) tx_ins = [] prev_tx = unhexlify('0025bc3c0fa8b7eb55b9437fdbd016870d18e0df0ace7bc9864efc38414147c8') tx_ins.append(TxIn( prev_tx=prev_tx, prev_index=0, script_sig = b'', sequence = 0xffffffff, )) tx_outs = [] h160 = decode_base58('mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2') tx_outs.append(TxOut(amount=int(0.99*100000000), script_pubkey=p2pkh_script(h160))) h160 = decode_base58('mnrVtF8DWjMu839VW3rBfgYaAfKk8983Xf') tx_outs.append(TxOut(amount=int(0.1*100000000), script_pubkey=p2pkh_script(h160))) tx = Tx( version=1, tx_ins=tx_ins, tx_outs=tx_outs, locktime=0, testnet=True, ) self.assertTrue(tx.sign_input(0, private_key, SIGHASH_ALL))
def test_exercise_3_2(self): prev_tx_1 = bytes.fromhex( '89cbfe2eddaddf1eb11f5c4adf6adaa9bca4adc01b2a3d03f8dd36125c068af4') prev_index_1 = 0 prev_tx_2 = bytes.fromhex( '19069e1304d95f70e03311d9d58ee821e0978e83ecfc47a30af7cd10fca55cf4') prev_index_2 = 0 target_address = 'mwJn1YPMq7y5F8J3LkC5Hxg9PHyZ5K4cFv' fee = 50000 secret = 61740721216174072121 private_key = PrivateKey(secret=secret) tx_ins = [] tx_ins.append(TxIn(prev_tx_1, prev_index_1)) tx_ins.append(TxIn(prev_tx_2, prev_index_2)) tx_outs = [] h160 = decode_base58(target_address) script_pubkey = p2pkh_script(h160) target_satoshis = tx_ins[0].value(True) + tx_ins[1].value(True) - fee tx_outs.append(TxOut(target_satoshis, script_pubkey)) tx_obj = Tx(1, tx_ins, tx_outs, 0, testnet=True) tx_obj.sign_input(0, private_key) tx_obj.sign_input(1, private_key) if tx_ins[0].script_pubkey( testnet=True).instructions[2] != decode_base58( private_key.point.address(testnet=True)): raise RuntimeError( 'Output is not something you can spend with this private key. Check that the prev_tx and prev_index are correct' ) if tx_obj.fee() > 0.05 * 100000000 or tx_obj.fee() <= 0: raise RuntimeError( 'Check that the change amount is reasonable. Fee is {}'.format( tx_obj.fee())) self.assertEqual( tx_obj.serialize().hex(), '0100000002f48a065c1236ddf8033d2a1bc0ada4bca9da6adf4a5c1fb11edfaddd2efecb89000000006a47304402204b9ee431a2f5deaefb5282a34d7dcfdb47d55b1e3ce00cac4c6b6e6f0f0e8d58022062710e84786d2c6c89ddda5a149b45088b15230c6b825f0f21490f99bd74c81d012103f96f3a1efd31e1a8d7078118ee56bff7355d58907ce0f865f5f0b3dbe34e55befffffffff45ca5fc10cdf70aa347fcec838e97e021e88ed5d91133e0705fd904139e0619000000006a473044022073d7217b2d582e55978284c2628015a14e3490e835c76488eb29b63de15d17920220384e4b5282c911273efd4d98170e7092e10a729d142db17f4725c15364fa4ecc012103f96f3a1efd31e1a8d7078118ee56bff7355d58907ce0f865f5f0b3dbe34e55beffffffff01021f320a000000001976a914ad346f8eb57dee9a37981716e498120ae80e44f788ac00000000' )
from ecc import PrivateKey from helper import hash256, little_endian_to_int mypass = b'KBU_201601071_PARKDONGHYUNE' mysecret = little_endian_to_int(hash256(mypass)) P = PrivateKey(mysecret) print(P.point.address(testnet=True))
import pprint raw="""\ 0491bba2510912a5bd37da1fb5b1673010e43d2c6d812c514e91bfa9f2eb129e1c183329db55bd868e209aac2fbc02cb33d98fe74bf23f0c235d6126b1d8334f86/5JaTXbAUmfPYZFRwrYaALK48fN6sFJp4rHqq2QSXs8ucfpE4yQU 04865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac09ef122b1a986818a7cb624532f062c1d1f8722084861c5c3291ccffef4ec6874/5Jb7fCeh1Wtm4yBBg3q3XbT6B525i17kVhy3vMC9AqfR6FH2qGk 048d2455d2403e08708fc1f556002f1b6cd83f992d085097f9974ab08a28838f07896fbab08f39495e15fa6fad6edbfb1e754e35fa1c7844c41f322a1863d46213/5JFjmGo5Fww9p8gvx48qBYDJNAzR9pmH5S389axMtDyPT8ddqmw\ """ from ecc import PrivateKey, S256Point from helper import little_endian_to_int, big_endian_to_int from binascii import unhexlify, hexlify import script import helper from tx import TxIn, TxOut, Tx key_pairs = [x.split('/') for x in map(str.strip,raw.split('\n'))] key_pairs = [(S256Point.parse(unhexlify(sec)), PrivateKey.parse(wif, compressed=False)) for sec, wif in key_pairs] assert all(p == pk.point for p,pk in key_pairs) pubkeys = [p for p, _ in key_pairs] OP_n = lambda n: 0x51 + n - 1 n_required = 2 elements = [OP_n(n_required)] + [pk.sec(compressed=False) for pk in pubkeys] + [OP_n(len(pubkeys))] + [174] redeemScript = script.Script(elements) address=helper.h160_to_p2sh_address(helper.hash160(redeemScript.serialize()), testnet=False) redeemScript=hexlify(redeemScript.serialize()) assert address=="3QJmV3qfvL9SuYo34YihAf3sRCW3qSinyC" assert redeemScript=="52410491bba2510912a5bd37da1fb5b1673010e43d2c6d812c514e91bfa9f2eb129e1c183329db55bd868e209aac2fbc02cb33d98fe74bf23f0c235d6126b1d8334f864104865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac09ef122b1a986818a7cb624532f062c1d1f8722084861c5c3291ccffef4ec687441048d2455d2403e08708fc1f556002f1b6cd83f992d085097f9974ab08a28838f07896fbab08f39495e15fa6fad6edbfb1e754e35fa1c7844c41f322a1863d4621353ae".encode('ascii') print(hexlify(helper.hash160(unhexlify(redeemScript))))
from ecc import PrivateKey from helper import hash256, little_endian_to_int passphrase = b'pickmeupimscared1419' secret = little_endian_to_int(hash256(passphrase)) priv = PrivateKey(secret) print(priv.point.address(testnet=True))
from ecc import PrivateKey priv = PrivateKey(5000) print(priv.point.sec(compressed=False).hex()) priv = PrivateKey(2018**5) print(priv.point.sec(compressed=False).hex()) priv = PrivateKey(0xdeadbeef12345) print(priv.point.sec(compressed=False).hex())