def get_address_from_pubkey(hex_pubkey): """ get bitcoin address from pub key """ pubkey = BitcoinPublicKey(hex_pubkey) return pubkey.address()
class AuthResponseTest(unittest.TestCase): def setUp(self): self.private_key_hex = str(PRIVATE_KEY) self.public_key_hex = str(PUBLIC_KEY) self.private_key = BitcoinPrivateKey(self.private_key_hex) self.public_key = BitcoinPublicKey(self.public_key_hex) self.profile = RYAN_PROFILE self.username = '******' self.sample_encoded_token = RESPONSE_SAMPLE_ENCODED_TOKEN self.sample_decoded_token = RESPONSE_SAMPLE_DECODED_TOKEN def tearDown(self): pass def test_auth_response_token_encoding(self): # without username, testing basics auth_response = AuthResponse(self.private_key_hex, RYAN_PROFILE) auth_response_token = auth_response.token() decoded_token = AuthResponse.decode(auth_response_token) payload = decoded_token['payload'] self.assertEqual(payload['public_keys'][0], self.public_key_hex) self.assertEqual(get_address_from_did(payload['iss']), self.public_key.address()) self.assertEqual(payload['profile'], self.profile) self.assertEqual(payload['username'], None) self.assertTrue(AuthResponse.verify(auth_response_token)) # with username with requests_mock.mock() as m: m.get(LOCALHOST_CORE_API + NAME_LOOKUP_URL + self.username, text=json.dumps({'address': self.public_key.address()})) auth_response = AuthResponse(self.private_key_hex, RYAN_PROFILE, self.username) auth_response_token = auth_response.token() self.assertTrue( do_public_keys_match_username( auth_response_token, Tokenizer(), AuthResponse.decode(auth_response_token))) self.assertTrue(AuthResponse.verify(auth_response_token)) def test_auth_response_token_decoding(self): decoded_token = AuthResponse.decode(self.sample_encoded_token) self.assertEqual(decoded_token, self.sample_decoded_token)
def broadcast(name, data_hash, consensus_hash, private_key, blockchain_client, blockchain_broadcaster=None, tx_only=False, user_public_key=None, testset=False): """ Write a name update into the blockchain. Returns a JSON object with 'data' set to the nulldata and 'transaction_hash' set to the transaction hash on success. """ # sanity check pay_fee = True if user_public_key is not None: pay_fee = False tx_only = True if user_public_key is None and private_key is None: raise Exception("Missing both public and private key") if not tx_only and private_key is None: raise Exception("Need private key for broadcasting") if blockchain_broadcaster is None: blockchain_broadcaster = blockchain_client from_address = None inputs = None private_key_obj = None if user_public_key is not None: # subsidizing pubk = BitcoinPublicKey( user_public_key ) from_address = pubk.address() # get inputs from utxo provider inputs = get_unspents( from_address, blockchain_client ) elif private_key is not None: # ordering directly pubk = BitcoinPrivateKey( private_key ).public_key() public_key = pubk.to_hex() # get inputs and from address using private key private_key_obj, from_address, inputs = analyze_private_key(private_key, blockchain_client) nulldata = build(name, consensus_hash, data_hash=data_hash, testset=testset) outputs = make_outputs( nulldata, inputs, from_address, pay_fee=pay_fee ) if tx_only: unsigned_tx = serialize_transaction( inputs, outputs ) return {'unsigned_tx': unsigned_tx} else: signed_tx = tx_serialize_and_sign( inputs, outputs, private_key_obj ) response = broadcast_transaction( signed_tx, blockchain_broadcaster ) response.update({'data': nulldata}) return response
def broadcast(name, destination_address, keepdata, consensus_hash, private_key, blockchain_client, blockchain_broadcaster=None, tx_only=False, user_public_key=None, testset=False): # sanity check pay_fee = True if user_public_key is not None: pay_fee = False tx_only = True if user_public_key is None and private_key is None: raise Exception("Missing both public and private key") if not tx_only and private_key is None: raise Exception("Need private key for broadcasting") if blockchain_broadcaster is None: blockchain_broadcaster = blockchain_client from_address = None inputs = None private_key_obj = None if user_public_key is not None: # subsidizing pubk = BitcoinPublicKey( user_public_key ) from_address = pubk.address() inputs = get_unspents( from_address, blockchain_client ) elif private_key is not None: # ordering directly pubk = BitcoinPrivateKey( private_key ).public_key() public_key = pubk.to_hex() # get inputs and from address using private key private_key_obj, from_address, inputs = analyze_private_key(private_key, blockchain_client) nulldata = build(name, keepdata, consensus_hash, testset=testset) outputs = make_outputs(nulldata, inputs, destination_address, from_address, pay_fee=pay_fee, format='hex') if tx_only: unsigned_tx = serialize_transaction( inputs, outputs ) return {"unsigned_tx": unsigned_tx} else: # serialize, sign, and broadcast the tx response = serialize_sign_and_broadcast(inputs, outputs, private_key_obj, blockchain_broadcaster) response.update({'data': nulldata}) return response
class AuthRequestTest(unittest.TestCase): def setUp(self): self.private_key_hex = str(PRIVATE_KEY) self.public_key_hex = str(PUBLIC_KEY) self.domain_name = 'localhost:3000' self.private_key = BitcoinPrivateKey(self.private_key_hex) self.public_key = BitcoinPublicKey(self.public_key_hex) self.sample_encoded_token = REQUEST_SAMPLE_ENCODED_TOKEN self.sample_decoded_token = REQUEST_SAMPLE_DECODED_TOKEN self.maxDiff = None def tearDown(self): pass def test_auth_request_token_encoding(self): # valid AuthRequest auth_request = AuthRequest(self.private_key_hex, self.domain_name) auth_request_token = auth_request.token() decoded_token = AuthRequest.decode(auth_request_token) payload = decoded_token['payload'] self.assertEqual(payload['public_keys'][0], self.public_key_hex) self.assertEqual(get_address_from_did(payload['iss']), self.public_key.address()) self.assertEqual(payload['scopes'], []) self.assertEqual(payload['manifest_uri'], self.domain_name + '/manifest.json') self.assertTrue(AuthRequest.verify(auth_request_token)) # invalid AuthRequest auth_request = AuthRequest(self.private_key_hex, self.domain_name) auth_request_token = auth_request.token()[:-1] self.assertFalse(AuthRequest.verify(auth_request_token)) def test_auth_request_token_decoding(self): decoded_token = AuthRequest.decode(self.sample_encoded_token) self.assertEqual(decoded_token, self.sample_decoded_token) def test_custom_openssl_backend(self): auth_request = AuthRequest(self.private_key_hex, self.domain_name, crypto_backend=openssl_backend) auth_request_token = auth_request.token() self.assertTrue(AuthRequest.verify(auth_request_token))
def broadcast(name, destination_address, keepdata, consensus_hash, private_key, blockchain_client, blockchain_broadcaster=None, tx_only=False, user_public_key=None, testset=False): # sanity check pay_fee = True if user_public_key is not None: pay_fee = False tx_only = True if user_public_key is None and private_key is None: raise Exception("Missing both public and private key") if not tx_only and private_key is None: raise Exception("Need private key for broadcasting") if blockchain_broadcaster is None: blockchain_broadcaster = blockchain_client from_address = None inputs = None private_key_obj = None if user_public_key is not None: # subsidizing pubk = BitcoinPublicKey(user_public_key) from_address = pubk.address() inputs = get_unspents(from_address, blockchain_client) elif private_key is not None: # ordering directly pubk = BitcoinPrivateKey(private_key).public_key() public_key = pubk.to_hex() # get inputs and from address using private key private_key_obj, from_address, inputs = analyze_private_key( private_key, blockchain_client) nulldata = build(name, keepdata, consensus_hash, testset=testset) outputs = make_outputs(nulldata, inputs, destination_address, from_address, pay_fee=pay_fee, format='hex') if tx_only: unsigned_tx = serialize_transaction(inputs, outputs) return {"unsigned_tx": unsigned_tx} else: # serialize, sign, and broadcast the tx response = serialize_sign_and_broadcast(inputs, outputs, private_key_obj, blockchain_broadcaster) response.update({'data': nulldata}) return response
def broadcast(name, data_hash, consensus_hash, private_key, blockchain_client, blockchain_broadcaster=None, tx_only=False, user_public_key=None, testset=False): """ Write a name update into the blockchain. Returns a JSON object with 'data' set to the nulldata and 'transaction_hash' set to the transaction hash on success. """ # sanity check pay_fee = True if user_public_key is not None: pay_fee = False tx_only = True if user_public_key is None and private_key is None: raise Exception("Missing both public and private key") if not tx_only and private_key is None: raise Exception("Need private key for broadcasting") if blockchain_broadcaster is None: blockchain_broadcaster = blockchain_client from_address = None inputs = None private_key_obj = None if user_public_key is not None: # subsidizing pubk = BitcoinPublicKey(user_public_key) from_address = pubk.address() # get inputs from utxo provider inputs = get_unspents(from_address, blockchain_client) elif private_key is not None: # ordering directly pubk = BitcoinPrivateKey(private_key).public_key() public_key = pubk.to_hex() # get inputs and from address using private key private_key_obj, from_address, inputs = analyze_private_key( private_key, blockchain_client) nulldata = build(name, consensus_hash, data_hash=data_hash, testset=testset) outputs = make_outputs(nulldata, inputs, from_address, pay_fee=pay_fee) if tx_only: unsigned_tx = serialize_transaction(inputs, outputs) return {'unsigned_tx': unsigned_tx} else: signed_tx = tx_serialize_and_sign(inputs, outputs, private_key_obj) response = broadcast_transaction(signed_tx, blockchain_broadcaster) response.update({'data': nulldata}) return response
output = open('pickled_tmpmap.dat', 'rb') tmpmap = pickle.load(output) # 'obj_dict' is a dict object else: if os.path.isfile("genesis.json") == False: print "Downloading Genesis Block" download_file() save_file() json_file = "genesis.json" json_data = open(json_file) data = json.load(json_data) for x in data: try: addy = "" pub = str(x["owner_pubkey"]) pbl = BitcoinPublicKey(pub) tmpmap[pub] = pbl.address() addy = tmpmap[pub] if addy not in balmap: balmap[addy] = 0 balmap[addy] += float(x["mir_amount"]) except Exception as e: print e output = open('pickled_tmpmap.dat', 'wb+') pickle.dump(tmpmap, output) output.close() output = open('pickled_balmap.dat', 'wb+') pickle.dump(balmap, output) output.close()