def _create_addresses(tx,batch,testnet=True): """ testnet is TRUE always. Change this for mainnet later. """ batch_size = 5 app_log.info(f" batch size {batch_size}. Represents the amount of blocks whose outputs are being encoded to addresses.") for height in range(batch*batch_size, batch_size*(batch + 1)): result = tx.run("MATCH (b:block {height:$height}) " "MATCH (x)<-[:CREATES]-(t:transaction)<-[:CONTAINS]-(b) " "RETURN x.script_pubkey, x.index, t.id", height=height) addresses = [] for output in result.data(): address = None addr_type = None raw_script_pubkey = output["x.script_pubkey"] b_sp = bytes.fromhex(raw_script_pubkey) length = encode_varint(len(b_sp)) stream = BytesIO(length+b_sp) try: script_pubkey = Script.parse(stream) if script_pubkey.is_p2pkh_script_pubkey(): address= h160_to_p2pkh_address(script_pubkey.cmds[2], testnet) addr_type = "P2PKH" elif script_pubkey.is_p2sh_script_pubkey(): address= h160_to_p2sh_address(script_pubkey.cmds[1], testnet) addr_type = "P2SH" elif script_pubkey.is_p2wpkh_script_pubkey() or script_pubkey.is_p2wsh_script_pubkey(): if testnet: address = segwit_addr.encode("tb",0,script_pubkey.cmds[1]) else: address = segwit_addr.encode("bc",0,script_pubkey.cmds[1]) if script_pubkey.is_p2wpkh_script_pubkey(): addr_type = "P2WPKH" else: addr_type = "P2WSH" elif len(script_pubkey.cmds)==2 and script_pubkey.cmds[1]==0xac: try: address = script_pubkey.cmds[0].hex() addr_type = "P2PK" except: app_log.info(f"P2PK failed {script_pubkey.cmds[0]} from tx: {output['t.id']}") except: app_log.info(f"script parsing failed in tx {output['t.id']} index {output['x.index']} ") if address is not None: address_dict = { "address":address, "type": addr_type, "tx_id":output["t.id"], "index":output["x.index"] } addresses.append(address_dict) if len(addresses)>0: result = tx.run("FOREACH (address in $addresses | \n" "MERGE (o:output {index:address.index})<-[:CREATES]-(:transaction {id:address.tx_id}) \n" "MERGE (a:address {address:address.address}) SET a.type=address.type \n" "MERGE (a)-[:HAS]->(o) )", addresses=addresses) return
def address(self, testnet=False): print('address', self.cmds) if self.is_p2pkh_script_pubkey(): # p2pkh print('p2pkh') # hash160 is the 3rd cmd h160 = self.cmds[2] # convert to p2pkh address using h160_to_p2pkh_address (remember testnet) return h160_to_p2pkh_address(h160, testnet) elif self.is_p2sh_script_pubkey(): # p2sh # hash160 is the 2nd cmd h160 = self.cmds[1] # convert to p2sh address using h160_to_p2sh_address (remember testnet) return h160_to_p2sh_address(h160, testnet) elif self.is_p2wpkh_script_pubkey(): witver = self.cmds[0] script = self.cmds[1] print('bech32 addr', script_to_bech32(script, witver, testnet)) return script_to_bech32(script, witver, testnet) elif self.is_p2wsh_script_pubkey(): witver = self.cmds[0] script = self.cmds[1] print('bech32 addr', script_to_bech32(script, witver, testnet)) return script_to_bech32(script, witver, testnet) elif self.is_p2pk_script_pubkey(): return 'P2PK' elif self.cmds[0] == 106: return 'OP_RETURN' raise ValueError('Unknown ScriptPubKey')
def address(self, testnet=False): '''Returns the address corresponding to the script''' sig_type = self.type() if sig_type == 'p2pkh': return h160_to_p2pkh_address(self.elements[2], testnet=testnet) elif sig_type == 'p2sh': return h160_to_p2sh_address(self.elements[1], testnet=testnet) else: return None
def address(self, testnet=False): '''Returns the address corresponding to the script''' if self.is_p2pkh_script_pubkey(): # p2pkh # hash160 is the 3rd instruction h160 = self.instructions[2] # convert to p2pkh address using h160_to_p2pkh_address (remember testnet) return h160_to_p2pkh_address(h160, testnet) elif self.is_p2sh_script_pubkey(): # p2sh # hash160 is the 2nd instruction h160 = self.instructions[1] # convert to p2sh address using h160_to_p2sh_address (remember testnet) return h160_to_p2sh_address(h160, testnet)
def address(self, testnet=False): '''Returns the address corresponding to the script''' # if p2pkh if self.is_p2pkh_script_pubkey(): # p2pkh # convert to p2pkh address using h160_to_p2pkh_address (remember testnet) return h160_to_p2pkh_address(self.hash160(), testnet) # if p2sh elif self.is_p2sh_script_pubkey(): # p2sh # convert to p2sh address using h160_to_p2sh_address (remember testnet) return h160_to_p2sh_address(self.hash160(), testnet) # raise a ValueError raise ValueError('Unknown ScriptPubKey')
def address(self, testnet=False): '''Returns the address corresponding to the script''' sig_type = self.type() if sig_type == 'p2pkh': # hash160 is the 3rd element h160 = self.elements[2] # convert to p2pkh address using h160_to_p2pkh_address (remember testnet) return h160_to_p2pkh_address(h160, testnet) elif sig_type == 'p2sh': # hash160 is the 2nd element h160 = self.elements[1] # convert to p2sh address using h160_to_p2sh_address (remember testnet) return h160_to_p2sh_address(h160, testnet)
def address(self, testnet=False): '''Returns the address corresponding to the script''' if self.is_p2pkh_script_pubkey(): # p2pkh # hash160 is the 3rd cmd h160 = self.cmds[2] # convert to p2pkh address using h160_to_p2pkh_address (remember testnet) return h160_to_p2pkh_address(h160, testnet) elif self.is_p2sh_script_pubkey(): # p2sh # hash160 is the 2nd cmd h160 = self.cmds[1] # convert to p2sh address using h160_to_p2sh_address (remember testnet) return h160_to_p2sh_address(h160, testnet) raise ValueError('Unknown ScriptPubKey')
def address(self, testnet=False): '''Returns the address corresponding to the script''' # HACK: just count how many items to determine what type it is if len(self.items) == 5: # p2pkh # hash160 is the 3rd item h160 = self.items[2] # convert to p2pkh address using h160_to_p2pkh_address (remember testnet) return h160_to_p2pkh_address(h160, testnet) elif len(self.items) == 3: # p2sh # hash160 is the 2nd item h160 = self.items[1] # convert to p2sh address using h160_to_p2sh_address (remember testnet) return h160_to_p2sh_address(h160, testnet)
def encode_address(_script_pubkey, testnet=True): address = "" addr_type = "" length = encode_varint(len(_script_pubkey)) stream = BytesIO(length + _script_pubkey) #stream = BytesIO(_script_pubkey) try: script_pubkey = Script.parse(stream) if script_pubkey.is_p2pkh_script_pubkey(): address = h160_to_p2pkh_address(script_pubkey.cmds[2], testnet) addr_type = "P2PKH" elif script_pubkey.is_p2sh_script_pubkey(): address = h160_to_p2sh_address(script_pubkey.cmds[1], testnet) addr_type = "P2SH" elif script_pubkey.is_p2wpkh_script_pubkey( ) or script_pubkey.is_p2wsh_script_pubkey(): if testnet: address = segwit_addr.encode("tb", 0, script_pubkey.cmds[1]) else: address = segwit_addr.encode("bc", 0, script_pubkey.cmds[1]) if script_pubkey.is_p2wpkh_script_pubkey(): addr_type = "P2WPKH" else: addr_type = "P2WSH" elif len(script_pubkey.cmds ) == 2 and script_pubkey.cmds[1] == 0xac: try: address = script_pubkey.cmds[0].hex() addr_type = "P2PK" except: app_log.info( f"P2PK failed {script_pubkey.cmds[0]} from tx: {output['t.id']}" ) except: app_log.info(f"script parsing failed.") return address, addr_type
def address(self, testnet=False): '''Returns the address corresponding to the script''' if self.is_p2pkh_script_pubkey(): # p2pkh # hash160 is the 3rd element h160 = self.instructions[2] # convert to p2pkh address using h160_to_p2pkh_address (remember testnet) return h160_to_p2pkh_address(h160, testnet) elif self.is_p2sh_script_pubkey(): # p2sh # hash160 is the 2nd element h160 = self.instructions[1] # convert to p2sh address using h160_to_p2sh_address (remember testnet) return h160_to_p2sh_address(h160, testnet) elif self.is_p2wpkh_script_pubkey(): # p2sh # hash160 is the 2nd element witness_program = self.raw_serialize() # convert to bech32 address using encode_bech32_checksum return encode_bech32_checksum(witness_program, testnet) elif self.is_p2wsh_script_pubkey(): # p2sh # hash160 is the 2nd element witness_program = self.raw_serialize() # convert to bech32 address using encode_bech32_checksum return encode_bech32_checksum(witness_program, testnet)
def address(self, testnet=False): '''Returns the address corresponding to the script''' sig_type = self.type() if sig_type == 'p2pkh': # hash160 is the 3rd element h160 = self.elements[2] # convert to p2pkh address using h160_to_p2pkh_address (remember testnet) return h160_to_p2pkh_address(h160, testnet) elif sig_type == 'p2sh': # hash160 is the 2nd element h160 = self.elements[1] # convert to p2sh address using h160_to_p2sh_address (remember testnet) return h160_to_p2sh_address(h160, testnet) elif sig_type == 'p2pk': return h160_to_p2pkh_address(hash160(self.elements[0]), testnet) elif sig_type == 'p2wpkh': import segwit_addr if self.elements[0] == b'': witver = 0 else: assert 0 return segwit_addr.encode("bc", witver, self.elements[1])
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)))) prev_tx = 'd6f72aab8ff86ff6289842a0424319bf2ddba85dc7c52757912297f948286389' prev_index = 0 tx_in = TxIn(unhexlify(prev_tx), prev_index, b'') h160 = helper.decode_base58_checksum(address)[1:] tx_out = TxOut(int(0.01*100e6), script_pubkey=helper.p2sh_script(h160)) t = Tx(version=1, tx_ins=[tx_in], tx_outs=[tx_out], locktime=0, testnet=False) raw_transaction = hexlify(t.serialize()) assert raw_transaction == "010000000189632848f99722915727c5c75da8db2dbf194342a0429828f66ff88fab2af7d60000000000ffffffff0140420f000000000017a914f815b036d9bbbce5e9f2a00abd1bf3dc91e955108700000000".encode('ascii') print(t)
def test_p2sh_address(self): h160 = unhexlify('74d691da1574e6b3c192ecfb52cc8984ee7b6c56') want = '3CLoMMyuoDQTPRD3XYZtCvgvkadrAdvdXh' self.assertEqual(h160_to_p2sh_address(h160, prefix=b'\x05'), want) want = '2N3u1R6uwQfuobCqbCgBkpsgBxvr1tZpe7B' self.assertEqual(h160_to_p2sh_address(h160, prefix=b'\xc4'), want)
#redeem script as op code dat_redeem_script_op = Script([0x52, public_key1, public_key2, 0x52, 0xae]) # we serialize it in binary dat_redeem_script_serialized = dat_redeem_script_op.serialize() # hash 160 dat_redeem_script_h160 = hash160(dat_redeem_script_serialized) # we get the address dat_redeem_script_address = h160_to_p2sh_address(dat_redeem_script_h160, testnet=True) # get it back in bytes dat_target_h160 = decode_base58(dat_redeem_script_address) # use the result to build our p2sh_script target_script = p2sh_script(dat_target_h160) print(target_script) print('is p2sh: {}'.format(target_script.is_p2sh_script_pubkey())) print(dat_redeem_script_h160) print() print(dat_redeem_script_address)