def test_sign_bitcoind_partially_signed_2_of_2(self): # Finish signing a 2 of 2 transaction, that already has one signature signed by bitcoind # This tx can be found on testnet3 blockchain # txid: 9618820d7037d2f32db798c92665231cd4599326f5bd99cb59d0b723be2a13a2 raw_script = ( "522103e33b41f5ed67a77d4c4c54b3e946bd30d15b8f66e42cb29fde059c168851165521" "02b92cb20a9fb1eb9656a74eeb7387636cf64cdf502ff50511830328c1b479986452ae" ) p2sh_lookup = build_p2sh_lookup([h2b(raw_script)]) partially_signed_raw_tx = ( "010000000196238f11a5fd3ceef4efd5a186a7e6b9217d900418e72aca917cd6a6e634" "e74100000000910047304402201b41b471d9dd93cf97eed7cfc39a5767a546f6bfbf3e" "0c91ff9ad23ab9770f1f02205ce565666271d055be1f25a7e52e34cbf659f6c70770ff" "59bd783a6fcd1be3dd0147522103e33b41f5ed67a77d4c4c54b3e946bd30d15b8f66e4" "2cb29fde059c16885116552102b92cb20a9fb1eb9656a74eeb7387636cf64cdf502ff5" "0511830328c1b479986452aeffffffff01a0bb0d00000000001976a9143b3beefd6f78" "02fa8706983a76a51467bfa36f8b88ac00000000") tx = Tx.from_hex(partially_signed_raw_tx) tx_out = TxOut(1000000, h2b("a914a10dfa21ee8c33b028b92562f6fe04e60563d3c087")) tx.set_unspents([tx_out]) key = Key.from_text( "cThRBRu2jAeshWL3sH3qbqdq9f4jDiDbd1SVz4qjTZD2xL1pdbsx") hash160_lookup = build_hash160_lookup([key.secret_exponent()]) self.assertEqual(tx.bad_signature_count(), 1) tx.sign(hash160_lookup=hash160_lookup, p2sh_lookup=p2sh_lookup) self.assertEqual(tx.bad_signature_count(), 0) self.assertEqual( tx.id(), "9618820d7037d2f32db798c92665231cd4599326f5bd99cb59d0b723be2a13a2")
def parse_scripts(args): scripts = [] warnings = [] for p2s in args.pay_to_script or []: try: scripts.append(h2b(p2s)) except Exception: warnings.append("warning: error parsing pay-to-script value %s" % p2s) hex_re = re.compile(r"[0-9a-fA-F]+") for f in args.pay_to_script_file or []: count = 0 for l in f: try: m = hex_re.search(l) if m: p2s = m.group(0) scripts.append(h2b(p2s)) count += 1 except Exception: warnings.append( "warning: error parsing pay-to-script file %s" % f.name) if count == 0: warnings.append("warning: no scripts found in %s" % f.name) return scripts, warnings
def check_bip143_tx(self, tx_u_hex, tx_s_hex, txs_out_value_scripthex_pair, tx_in_count, tx_out_count, version, lock_time): tx_u = Tx.from_hex(tx_u_hex) tx_s = Tx.from_hex(tx_s_hex) txs_out = [ TxOut(int(coin_value * 1e8), h2b(script_hex)) for coin_value, script_hex in txs_out_value_scripthex_pair ] for tx in (tx_u, tx_s): self.assertEqual(len(tx.txs_in), tx_in_count) self.assertEqual(len(tx.txs_out), tx_out_count) self.assertEqual(tx.version, version) self.assertEqual(tx.lock_time, lock_time) tx.set_unspents(txs_out) self.check_unsigned(tx_u) self.check_signed(tx_s) tx_hex = tx_u.as_hex() self.assertEqual(tx_hex, tx_u_hex) tx_hex = tx_s.as_hex() self.assertEqual(tx_hex, tx_s_hex) tx_u_prime = self.unsigned_copy(tx_s) tx_hex = tx_u_prime.as_hex() self.assertEqual(tx_hex, tx_u_hex) self.assertEqual(b2h_rev(double_sha256(h2b(tx_s_hex))), tx_s.w_id()) self.assertEqual(b2h_rev(double_sha256(h2b(tx_u_hex))), tx_u.w_id()) self.assertEqual(b2h_rev(double_sha256(h2b(tx_u_hex))), tx_u.id()) return tx_u, tx_s
def tx_from_json_dict(r): version = r.get("version") lock_time = r.get("locktime") txs_in = [] for vin in r.get("vin"): if "coinbase" in vin: previous_hash = b'\0' * 32 script = h2b(vin.get("coinbase")) previous_index = 4294967295 else: previous_hash = h2b_rev(vin.get("txid")) scriptSig = vin.get("scriptSig") if "hex" in scriptSig: script = h2b(scriptSig.get("hex")) else: script = tools.compile(scriptSig.get("asm")) previous_index = vin.get("vout") sequence = vin.get("sequence") txs_in.append(TxIn(previous_hash, previous_index, script, sequence)) txs_out = [] for vout in r.get("vout"): coin_value = btc_to_satoshi(decimal.Decimal(vout.get("value"))) script = tools.compile(vout.get("scriptPubKey").get("asm")) txs_out.append(TxOut(coin_value, script)) tx = Tx(version, txs_in, txs_out, lock_time) bh = r.get("blockhash") if bh: bh = h2b_rev(bh) tx.confirmation_block_hash = bh return tx
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58): secret_exponent = int(exp_hex, 16) sec = h2b(public_pair_sec) c_sec = h2b(c_public_pair_sec) keys_wif = [ Key(secret_exponent=secret_exponent), Key.from_text(wif), Key.from_text(c_wif), ] key_sec = Key.from_sec(sec) key_sec_c = Key.from_sec(c_sec) keys_sec = [key_sec, key_sec_c] for key in keys_wif: self.assertEqual(key.secret_exponent(), secret_exponent) self.assertEqual(key.public_copy().secret_exponent(), None) repr(key) if key._prefer_uncompressed: self.assertEqual(key.wif(), wif) else: self.assertEqual(key.wif(), c_wif) self.assertEqual(key.wif(use_uncompressed=True), wif) self.assertEqual(key.wif(use_uncompressed=False), c_wif) for key in keys_wif + keys_sec: if key._prefer_uncompressed: self.assertEqual(key.sec(), sec) else: self.assertEqual(key.sec(), c_sec) self.assertEqual(key.sec(use_uncompressed=True), sec) self.assertEqual(key.sec(use_uncompressed=False), c_sec) if key._prefer_uncompressed: self.assertEqual(key.address(), address_b58) else: self.assertEqual(key.address(), c_address_b58) self.assertEqual(key.address(use_uncompressed=False), c_address_b58) self.assertEqual(key.address(use_uncompressed=True), address_b58) key_pub = Key.from_text(address_b58, is_compressed=False) key_pub_c = Key.from_text(c_address_b58, is_compressed=True) self.assertEqual(key_pub.address(), address_b58) self.assertEqual(key_pub.address(use_uncompressed=True), address_b58) self.assertEqual(key_pub.address(use_uncompressed=False), None) self.assertEqual(key_pub_c.address(), c_address_b58) self.assertEqual(key_pub_c.address(use_uncompressed=True), None) self.assertEqual(key_pub_c.address(use_uncompressed=False), c_address_b58)
def test_hash160(self): def do_test(blob, expected_hash): self.assertEqual(encoding.hash160(blob), expected_hash) do_test(b"This is a test", h2b("18ac98fa2a2412ddb75de60459b52acd98f2d972")) do_test(b"The quick brown fox jumps over the lazy dogs", h2b("76c9d1f3aa5226554e20475f919aadd174f7e9b7")) do_test(b'\x74' * 10000, h2b("a961070296677401a57eae0d96d14d5a880a2c41"))
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58): secret_exponent = int(exp_hex, 16) sec = h2b(public_pair_sec) c_sec = h2b(c_public_pair_sec) self.assertEqual( secret_exponent_to_wif(secret_exponent, compressed=False), wif) self.assertEqual( secret_exponent_to_wif(secret_exponent, compressed=True), c_wif) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed( wif) self.assertEqual(exponent, secret_exponent) self.assertFalse(compressed) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed( c_wif) self.assertEqual(exponent, secret_exponent) self.assertTrue(compressed) public_pair = secret_exponent * secp256k1_generator pk_public_pair = sec_to_public_pair(sec) compressed = is_sec_compressed(sec) self.assertEqual(pk_public_pair, public_pair) self.assertFalse(is_sec_compressed(sec)) self.assertEqual( public_pair_to_sec(pk_public_pair, compressed=False), sec) pk_public_pair = sec_to_public_pair(c_sec) compressed = is_sec_compressed(c_sec) self.assertEqual(pk_public_pair, public_pair) self.assertTrue(compressed) self.assertEqual( public_pair_to_sec(pk_public_pair, compressed=True), c_sec) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=True) self.assertEqual(bca, c_address_b58) self.assertEqual( bitcoin_address_to_hash160_sec(c_address_b58), public_pair_to_hash160_sec(pk_public_pair, compressed=True)) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=False) self.assertEqual(bca, address_b58) self.assertEqual( bitcoin_address_to_hash160_sec(address_b58), public_pair_to_hash160_sec(pk_public_pair, compressed=False))
def test_to_from_long(self): def do_test(as_int, prefix, as_rep, base): self.assertEqual((as_int, prefix), encoding.to_long(base, lambda v: v, iterbytes(as_rep))) self.assertEqual( as_rep, encoding.from_long(as_int, prefix, base, lambda v: v)) do_test(10000101, 2, h2b("00009896e5"), 256) do_test(10000101, 3, h2b("0000009896e5"), 256) do_test(1460765565493402645157733592332121663123460211377, 1, h2b("00ffdefe4f4875cf119fc3d8f4a09ae37ec4cc42b1"), 256)
def test_to_from_base58(self): def do_test(as_text, as_bin): self.assertEqual(as_bin, encoding.a2b_base58(as_text)) self.assertEqual(as_text, encoding.b2a_base58(as_bin)) do_test("1abcdefghijkmnpqrst", h2b("0001935c7cf22ab9be1962aee48c7b")) do_test("1CASrvcpMMTa4dz4DmYtAqcegCtdkhjvdn", h2b("007a72b6fa63de36c4abc60a68b52d7f33e3d7cd3ec4babd39")) do_test("1111111111111111aaaa11aa", h2b("00000000000000000000000000000000436e7a51290b")) do_test( "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", h2b("000111d38e5fc9071ffcd20b4a763cc9ae4f252bb4e48fd66a835e252ada93ff480d6d" "d43dc62a641155a5"))
def dump_signatures(tx, tx_in, tx_out, idx, netcode, address_prefix, traceback_f, disassembly_level): signatures = [] for opcode in opcode_list(tx_in.script): if not opcode.startswith("OP_"): try: signatures.append(parse_signature_blob(h2b(opcode[1:-1]))) except UnexpectedDER: pass if signatures: sig_types_identical = (tuple(zip(*signatures))[1].count( signatures[0][1]) == len(signatures)) i = 1 if len(signatures) > 1 else '' for sig_pair, sig_type in signatures: print(" r{0}: {1:#x}\n s{0}: {2:#x}".format( i, *sig_pair)) if not sig_types_identical and tx_out: print(" z{}: {:#x} {}".format( i, tx.signature_hash(tx_out.script, idx, sig_type), sighash_type_to_string(sig_type))) if i: i += 1 if sig_types_identical and tx_out: print(" z:{} {:#x} {}".format( ' ' if i else '', tx.signature_hash(tx_out.script, idx, sig_type), sighash_type_to_string(sig_type)))
def spendables_for_address(self, bitcoin_address): """ Return a list of Spendable objects for the given bitcoin address. """ URL = "https://blockchain.info/unspent?active=%s" % bitcoin_address r = json.loads(urlopen(URL).read().decode("utf8")) spendables = [] for u in r["unspent_outputs"]: coin_value = u["value"] script = h2b(u["script"]) previous_hash = h2b(u["tx_hash"]) previous_index = u["tx_output_n"] spendables.append( Spendable(coin_value, script, previous_hash, previous_index)) return spendables
def test_double_sha256(self): def do_test(blob, expected_hash): self.assertEqual(encoding.double_sha256(blob), expected_hash) do_test( b"This is a test", h2b("eac649d431aa3fc2d5749d1a5021bba7812ec83b8a59fa840bff75c17f8a665c" )) do_test( b"The quick brown fox jumps over the lazy dogs", h2b("8a356588797a901a11031779d4787ad0457eb082c56bd9b657157acf31bae6c4" )) do_test( b'\x74' * 10000, h2b("6e4d7736aa373c4718eef2b94528fed57519a0bdc3a8f4300aee372cbedea9a0" ))
def make_script_test(script_in, script_out, flags_string, comment, expected, coin_value, script_witness): script_in_bin = compile(script_in) script_out_bin = compile(script_out) script_witness_bin = [h2b(w) for w in script_witness] flags = parse_flags(flags_string) def f(self): try: credit_tx = build_credit_tx(script_out_bin, coin_value) spend_tx = build_spending_tx(script_in_bin, credit_tx) spend_tx.txs_in[0].witness = script_witness_bin msg = '' check_solution(spend_tx, tx_in_idx=0, flags=flags) r = 0 except ScriptError as se: r = se.error_code() msg = se.args[0] except: r = -1 # for now, just deal with 0 versus nonzero expect_error = getattr(errno, expected) if r != expect_error: dump_failure_info(spend_tx, script_in, script_out, flags, flags_string, expected, r, msg, comment) self.assertEqual(r, expect_error) return f
def test_h2b(self): h = "000102" b = b"\x00\x01\x02" self.assertEqual(h2b(h), b) self.assertEqual(b2h(b), h) self.assertEqual(h2b_rev(h), b[::-1]) self.assertEqual(b2h_rev(b), "020100")
def test_block_dump(self): block_hex = ( '01000000bddd99ccfda39da1b108ce1a5d70038d0a967bacb68b6b63065f626a000000' '0044f672226090d85db9a9f2fbfe5f0f9609b387af7be5b7fbb7a1767c831c9e995dbe' '6649ffff001d05e0ed6d01010000000100000000000000000000000000000000000000' '00000000000000000000000000ffffffff0704ffff001d010effffffff0100f2052a01' '00000043410494b9d3e76c5b1629ecf97fff95d7a4bbdac87cc26099ada28066c6ff1e' 'b9191223cd897194a08d0c2726c5747f1db49e8cf90e75dc3e3550ae9b30086f3cd5aa' 'ac00000000') block_bin = h2b(block_hex) block_file = tempfile.NamedTemporaryFile() block_file.write(block_bin) block_file.flush() output = self.launch_tool("block %s" % block_file.name) self.assertEqual(output, """215 bytes block hash 0000000082b5015589a3fdf2d4baff403e6f0be035a5d9742c1cae6295464449 version 1 prior block hash 000000006a625f06636b8bb6ac7b960a8d03705d1ace08b1a19da3fdcc99ddbd merkle root 44f672226090d85db9a9f2fbfe5f0f9609b387af7be5b7fbb7a1767c831c9e99 timestamp 2009-01-09T03:02:53 difficulty 486604799 nonce 1844305925 1 transaction Tx #0: Version: 1 tx hash 999e1c837c76a1b7fbb7e57baf87b309960f5ffefbf2a9b95dd890602272f644 134 bytes TxIn count: 1; TxOut count: 1 Lock time: 0 (valid anytime) Input: 0: COINBASE 50000.00000 mBTC Output: 0: 1FvzCLoTPGANNjWoUo6jUGuAG3wg1w4YjR receives 50000.00000 mBTC Total input 50000.00000 mBTC Total output 50000.00000 mBTC Total fees 0.00000 mBTC """)
def main(): if len(sys.argv) != 4: print("usage: %s tx-hex-file-path wif-file-path p2sh-file-path" % sys.argv[0]) sys.exit(-1) # get the tx with open(sys.argv[1], "r") as f: tx_hex = f.readline().strip() tx = Tx.from_hex(tx_hex) # get the WIF with open(sys.argv[2], "r") as f: wif = f.readline().strip() assert is_wif_valid(wif) # create the p2sh_lookup with open(sys.argv[3], "r") as f: p2sh_script_hex = f.readline().strip() p2sh_script = h2b(p2sh_script_hex) # build a dictionary of script hashes to scripts p2sh_lookup = build_p2sh_lookup([p2sh_script]) # sign the transaction with the given WIF sign_tx(tx, wifs=[wif], p2sh_lookup=p2sh_lookup) bad_signature_count = tx.bad_signature_count() print("tx %s now has %d bad signature(s)" % (tx.id(), bad_signature_count)) include_unspents = (bad_signature_count > 0) print("Here is the tx as hex:\n%s" % tx.as_hex(include_unspents=include_unspents))
def test_p2sh_multisig_sequential_signing(self): raw_scripts = [ h2b("52210234abcffd2e80ad01c2ec0276ad02682808169c6fafdd25ebfb60703df272b461" "2102e5baaafff8094e4d77ce8b009d5ebc3de9110085ebd3d96e50cc7ce70faf175221" "0316ee25e80eb6e6fc734d9c86fa580cbb9c4bfd94a19f0373a22353ececd4db6853ae" ) ] txs_in = [ TxIn(previous_hash=h2b( '43c95d14724437bccc102ccf86aba1ac02415524fd1aefa787db886bba52a10c' ), previous_index=0) ] txs_out = [ TxOut(10000, standard_tx_out_script('3KeGeLFmsbmbVdeMLrWp7WYKcA3tdsB4AR')) ] spendable = { 'script_hex': 'a914c4ed4de526461e3efbb79c8b688a6f9282c0464687', 'does_seem_spent': 0, 'block_index_spent': 0, 'coin_value': 10000, 'block_index_available': 0, 'tx_out_index': 0, 'tx_hash_hex': '0ca152ba6b88db87a7ef1afd24554102aca1ab86cf2c10ccbc374472145dc943' } tx__prototype = Tx(version=DEFAULT_VERSION, txs_in=txs_in, txs_out=txs_out, unspents=[Spendable.from_dict(spendable)]) key_1 = 'Kz6pytJCigYHeMsGLmfHQPJhN5og2wpeSVrU43xWwgHLCAvpsprh' key_2 = 'Kz7NHgX7MBySA3RSKj9GexUSN6NepEDoPNugSPr5absRDoKgn2dT' for ordered_keys in [(key_1, key_2), (key_2, key_1)]: tx = copy.deepcopy(tx__prototype) for key in ordered_keys: self.assertEqual(tx.bad_signature_count(), 1) tx.sign(LazySecretExponentDB([key], {}), p2sh_lookup=build_p2sh_lookup(raw_scripts)) self.assertEqual(tx.bad_signature_count(), 0)
def spendable_for_row(r): return Spendable(coin_value=r[2], script=h2b(r[3]), tx_hash=h2b_rev(r[0]), tx_out_index=r[1], block_index_available=r[4], does_seem_spent=r[5], block_index_spent=r[6])
def test_to_from_hashed_base58(self): def do_test(as_text, as_bin): self.assertEqual(as_text, encoding.b2a_hashed_base58(as_bin)) self.assertEqual(as_bin, encoding.a2b_hashed_base58(as_text)) self.assertTrue(encoding.is_hashed_base58_valid(as_text)) bogus_text = as_text[:-1] + chr(1 + ord(as_text[-1])) self.assertFalse(encoding.is_hashed_base58_valid(bogus_text)) do_test("14nr3dMd4VwNpFhFECU1A6imi", h2b("0001935c7cf22ab9be1962aee48c7b")) do_test("1CASrvcpMMTa4dz4DmYtAqcegCtdkhjvdn", h2b("007a72b6fa63de36c4abc60a68b52d7f33e3d7cd3e")) do_test("11111111111111114njGbaozZJui9o", h2b("00000000000000000000000000000000436e7a51290b")) do_test( "1mLRia5CbfDB9752zxvtrpnkigecaYWUSQNLJGECA8641ywusqomjhfdb6EM7bXGj1Gb", h2b("000111d38e5fc9071ffcd20b4a763cc9ae4f252bb4e48fd66a835e252ada93ff480d6dd43dc62a641155a561616161" ))
def test_PeerAddress(self): pa = PeerAddress(188, IP4_HEADER + h2b("c0a80163"), 8333) pa_bytes = to_bin(pa) pa1 = from_bin(PeerAddress, pa_bytes) self.assertEqual(pa, pa1) pa2 = PeerAddress(188, IP4_HEADER + h2b("c0a80162"), 8333) self.assertTrue(pa1 > pa2) self.assertTrue(pa1 >= pa2) self.assertTrue(pa2 < pa1) self.assertTrue(pa2 <= pa1) self.assertNotEqual(pa2, pa1) self.assertNotEqual(pa1, pa2) self.assertEqual(pa1.host(), "192.168.1.99") self.assertEqual(repr(pa1), "192.168.1.99/8333") pa_v6 = PeerAddress(945, h2b("2607f8b04006080a000000000000200e"), 8333) self.assertEqual(pa_v6.host(), "2607:f8b0:4006:80a:0:0:0:200e")
def test_sec(self): pair_blob = h2b( "0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483a" "da7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8") encoding.sec_to_public_pair(pair_blob, strict=False) try: encoding.sec_to_public_pair(pair_blob, strict=True) self.fail("sec_to_public_pair unexpectedly succeeded") except encoding.EncodingError: pass
def parse_key(item, PREFIX_TRANSFORMS, network): key = parse_prefixes(item, PREFIX_TRANSFORMS) if key: return key if HASH160_RE.match(item): return Key(hash160=h2b(item), netcode=network) secret_exponent = parse_as_secret_exponent(item) if secret_exponent: return Key(secret_exponent=secret_exponent, netcode=network) if SEC_RE.match(item): return Key.from_sec(h2b(item)) public_pair = parse_as_public_pair(item) if public_pair: return Key(public_pair=public_pair, netcode=network) return None
def tx_for_tx_hash(self, tx_hash): """ returns the pycoin.tx object for tx_hash """ try: url_append = "?token=%s&includeHex=true" % self.api_key url = self.base_url("txs/%s%s" % (b2h_rev(tx_hash), url_append)) result = json.loads(urlopen(url).read().decode("utf8")) tx = Tx.parse(io.BytesIO(h2b(result.get("hex")))) return tx except: raise Exception
def test_testnet(self): # WARNING: these values have not been verified independently. TODO: do so master = BIP32Node.from_master_secret( h2b("000102030405060708090a0b0c0d0e0f"), netcode='XTN') self.assertEqual( master.wallet_key(as_private=True), "tprv8ZgxMBicQKsPeDgjzdC36fs6bMjGApWDNLR9erAXMs5skhMv36j9MV5ecvfavji5kh" "qjWaWSFhN3YcCUUdiKH6isR4Pwy3U5y5egddBr16m") self.assertEqual(master.bitcoin_address(), "mkHGce7dctSxHgaWSSbmmrRWsZfzz7MxMk") self.assertEqual( master.wif(), "cVPXTF2TnozE1PenpP3x9huctiATZmp27T9Ue1d8nqLSExoPwfN5")
def check_tx_can_be_signed(self, tx_u, tx_s, private_keys=[], p2sh_values=[]): tx_u_prime = self.unsigned_copy(tx_s) tx_s_hex = tx_s.as_hex() tx_u_prime.set_unspents(tx_s.unspents) tx_u_prime.sign(hash160_lookup=LazySecretExponentDB( [Key(pk).wif() for pk in private_keys], {}), p2sh_lookup=build_p2sh_lookup( [h2b(x) for x in p2sh_values])) self.check_signed(tx_u_prime) tx_hex = tx_u_prime.as_hex() self.assertEqual(tx_hex, tx_s_hex)
def test_sign(self): sv = 33143560198659167577410026742586567991638126035902913554051654024377193788946 tx_out_script = b'v\xa9\x14\x91\xb2K\xf9\xf5(\x852\x96\n\xc6\x87\xab\xb05\x12{\x1d(\xa5\x88\xac' st = script_obj_from_script(tx_out_script) hl = build_hash160_lookup([1]) solution = st.solve(hash160_lookup=hl, signature_for_hash_type_f=const_f(sv), signature_type=SIGHASH_ALL) self.assertEqual( solution, h2b("47304402205e3df5b55be62140042c220b1fdf105cc85113af562a215c1fc5b5c522d1" "b3d3022038c9594b156faed7f37c30077affbf6acf42bf17b1e639a1fcc6c51a67aba2" "1601410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f817" "98483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8" ))
def spendable_for_hash_index(self, tx_hash, tx_out_index): tx_hash_hex = b2h_rev(tx_hash) SQL = ("select coin_value, script, block_index_available, " "does_seem_spent, block_index_spent from Spendable where " "tx_hash = ? and tx_out_index = ?") c = self._exec_sql(SQL, tx_hash_hex, tx_out_index) r = c.fetchone() if r is None: return r return Spendable(coin_value=r[0], script=h2b(r[1]), tx_hash=tx_hash, tx_out_index=tx_out_index, block_index_available=r[2], does_seem_spent=r[3], block_index_spent=r[4])
def spendables_for_address(self, bitcoin_address): """ Return a list of Spendable objects for the given bitcoin address. """ URL = "%s/addr/%s/utxo" % (self.base_url, bitcoin_address) r = json.loads(urlopen(URL).read().decode("utf8")) spendables = [] for u in r: coin_value = btc_to_satoshi(str(u.get("amount"))) script = h2b(u.get("scriptPubKey")) previous_hash = h2b_rev(u.get("txid")) previous_index = u.get("vout") spendables.append( Spendable(coin_value, script, previous_hash, previous_index)) return spendables
def spendables_for_address(self, address): """ Return a list of Spendable objects for the given bitcoin address. """ spendables = [] r = json.loads(urlopen(self.base_url('get_tx_unspent', address)).read().decode("utf8")) for u in r['data']['txs']: coin_value = int(float(u['value']) * 100000000) script = h2b(u["script_hex"]) previous_hash = h2b_rev(u["txid"]) previous_index = u["output_no"] spendables.append(Spendable(coin_value, script, previous_hash, previous_index)) return spendables
def spendables_for_address(self, address): """ Return a list of Spendable objects for the given bitcoin address. """ spendables = [] url_append = "?unspentOnly=true&token=%s&includeScript=true" % self.api_key url = self.base_url("addrs/%s%s" % (address, url_append)) result = json.loads(urlopen(url).read().decode("utf8")) for txn in result.get("txrefs", []): coin_value = txn.get("value") script = h2b(txn.get("script")) previous_hash = h2b_rev(txn.get("tx_hash")) previous_index = txn.get("tx_output_n") spendables.append( Spendable(coin_value, script, previous_hash, previous_index)) return spendables