From ffe326fa32fe7ac22d65add44bdfbab50bd09dd3 Mon Sep 17 00:00:00 2001 From: Jonathan Zernik Date: Sat, 14 Nov 2020 19:28:39 -0500 Subject: [PATCH] Refactor squeak node into controller and node (#461) * Rename squeak node to squeak controller * Rename SqueakNode class to SqueakController * Got itest working with refactored squeaknode and squeakcontroller classes --- .../admin/squeak_admin_server_handler.py | 70 ++-- squeaknode/main.py | 22 +- squeaknode/node/sent_offers_worker.py | 6 +- .../node/squeak_block_periodic_worker.py | 6 +- squeaknode/node/squeak_block_queue_worker.py | 6 +- squeaknode/node/squeak_controller.py | 361 ++++++++++++++++++ .../node/squeak_expired_offer_cleaner.py | 17 +- squeaknode/node/squeak_node.py | 341 +---------------- squeaknode/node/squeak_offer_expiry_worker.py | 6 +- squeaknode/node/squeak_peer_sync_worker.py | 6 +- squeaknode/server/squeak_server_handler.py | 16 +- 11 files changed, 448 insertions(+), 409 deletions(-) create mode 100644 squeaknode/node/squeak_controller.py diff --git a/squeaknode/admin/squeak_admin_server_handler.py b/squeaknode/admin/squeak_admin_server_handler.py index 3d620733..7206c873 100644 --- a/squeaknode/admin/squeak_admin_server_handler.py +++ b/squeaknode/admin/squeak_admin_server_handler.py @@ -2,7 +2,7 @@ import sys import logging from squeaknode.lightning.lnd_lightning_client import LNDLightningClient -from squeaknode.node.squeak_node import SqueakNode +from squeaknode.node.squeak_controller import SqueakController from squeaknode.server.util import get_hash, get_replyto from squeaknode.admin.util import squeak_entry_to_message from squeaknode.admin.util import squeak_peer_to_message @@ -26,10 +26,10 @@ class SqueakAdminServerHandler(object): def __init__( self, lightning_client: LNDLightningClient, - squeak_node: SqueakNode, + squeak_controller: SqueakController, ): self.lightning_client = lightning_client - self.squeak_node = squeak_node + self.squeak_controller = squeak_controller def handle_lnd_get_info(self, request): logger.info("Handle lnd get info") @@ -82,7 +82,7 @@ class SqueakAdminServerHandler(object): def handle_create_signing_profile(self, request): profile_name = request.profile_name logger.info("Handle create signing profile with name: {}".format(profile_name)) - profile_id = self.squeak_node.create_signing_profile(profile_name) + profile_id = self.squeak_controller.create_signing_profile(profile_name) logger.info("New profile_id: {}".format(profile_id)) return squeak_admin_pb2.CreateSigningProfileReply( profile_id=profile_id, @@ -95,7 +95,7 @@ class SqueakAdminServerHandler(object): profile_name, squeak_address, )) - profile_id = self.squeak_node.create_contact_profile( + profile_id = self.squeak_controller.create_contact_profile( profile_name, squeak_address ) logger.info("New profile_id: {}".format(profile_id)) @@ -105,7 +105,7 @@ class SqueakAdminServerHandler(object): def handle_get_signing_profiles(self, request): logger.info("Handle get signing profiles.") - profiles = self.squeak_node.get_signing_profiles() + profiles = self.squeak_controller.get_signing_profiles() logger.info("Got number of signing profiles: {}".format(len(profiles))) profile_msgs = [ squeak_profile_to_message(profile) for profile in profiles @@ -114,7 +114,7 @@ class SqueakAdminServerHandler(object): def handle_get_contact_profiles(self, request): logger.info("Handle get contact profiles.") - profiles = self.squeak_node.get_contact_profiles() + profiles = self.squeak_controller.get_contact_profiles() logger.info("Got number of contact profiles: {}".format(len(profiles))) profile_msgs = [ squeak_profile_to_message(profile) for profile in profiles @@ -124,7 +124,7 @@ class SqueakAdminServerHandler(object): def handle_get_squeak_profile(self, request): profile_id = request.profile_id logger.info("Handle get squeak profile with id: {}".format(profile_id)) - squeak_profile = self.squeak_node.get_squeak_profile(profile_id) + squeak_profile = self.squeak_controller.get_squeak_profile(profile_id) if squeak_profile is None: return None squeak_profile_msg = squeak_profile_to_message(squeak_profile) @@ -135,14 +135,14 @@ class SqueakAdminServerHandler(object): def handle_get_squeak_profile_by_address(self, request): address = request.address logger.info("Handle get squeak profile with address: {}".format(address)) - squeak_profile = self.squeak_node.get_squeak_profile_by_address(address) + squeak_profile = self.squeak_controller.get_squeak_profile_by_address(address) squeak_profile_msg = squeak_profile_to_message(squeak_profile) return squeak_admin_pb2.GetSqueakProfileByAddressReply(squeak_profile=squeak_profile_msg) def handle_get_squeak_profile_by_name(self, request): name = request.name logger.info("Handle get squeak profile with name: {}".format(name)) - squeak_profile = self.squeak_node.get_squeak_profile_by_name(name) + squeak_profile = self.squeak_controller.get_squeak_profile_by_name(name) squeak_profile_msg = squeak_profile_to_message(squeak_profile) return squeak_admin_pb2.GetSqueakProfileByNameReply(squeak_profile=squeak_profile_msg) @@ -155,7 +155,7 @@ class SqueakAdminServerHandler(object): following, ) ) - self.squeak_node.set_squeak_profile_following(profile_id, following) + self.squeak_controller.set_squeak_profile_following(profile_id, following) return squeak_admin_pb2.SetSqueakProfileFollowingReply() def handle_set_squeak_profile_sharing(self, request): @@ -167,13 +167,13 @@ class SqueakAdminServerHandler(object): sharing, ) ) - self.squeak_node.set_squeak_profile_sharing(profile_id, sharing) + self.squeak_controller.set_squeak_profile_sharing(profile_id, sharing) return squeak_admin_pb2.SetSqueakProfileSharingReply() def handle_delete_squeak_profile(self, request): profile_id = request.profile_id logger.info("Handle delete squeak profile with id: {}".format(profile_id)) - self.squeak_node.delete_squeak_profile(profile_id) + self.squeak_controller.delete_squeak_profile(profile_id) return squeak_admin_pb2.DeleteSqueakProfileReply() def handle_make_squeak(self, request): @@ -182,7 +182,7 @@ class SqueakAdminServerHandler(object): replyto_hash_str = request.replyto replyto_hash = bytes.fromhex(replyto_hash_str) if replyto_hash_str else None logger.info("Handle make squeak profile with id: {}".format(profile_id)) - inserted_squeak_hash = self.squeak_node.make_squeak( + inserted_squeak_hash = self.squeak_controller.make_squeak( profile_id, content_str, replyto_hash ) return squeak_admin_pb2.MakeSqueakReply( @@ -192,7 +192,7 @@ class SqueakAdminServerHandler(object): def handle_get_squeak_display_entry(self, request): squeak_hash = request.squeak_hash logger.info("Handle get squeak display entry for hash: {}".format(squeak_hash)) - squeak_entry_with_profile = self.squeak_node.get_squeak_entry_with_profile( + squeak_entry_with_profile = self.squeak_controller.get_squeak_entry_with_profile( squeak_hash ) display_message = squeak_entry_to_message(squeak_entry_with_profile) @@ -203,7 +203,7 @@ class SqueakAdminServerHandler(object): def handle_get_followed_squeak_display_entries(self, request): logger.info("Handle get followed squeak display entries.") squeak_entries_with_profile = ( - self.squeak_node.get_followed_squeak_entries_with_profile() + self.squeak_controller.get_followed_squeak_entries_with_profile() ) logger.info( "Got number of followed squeak entries: {}".format( @@ -224,7 +224,7 @@ class SqueakAdminServerHandler(object): max_block = sys.maxsize logger.info("Handle get squeak display entries for address: {}".format(address)) squeak_entries_with_profile = ( - self.squeak_node.get_squeak_entries_with_profile_for_address( + self.squeak_controller.get_squeak_entries_with_profile_for_address( address, min_block, max_block, @@ -251,7 +251,7 @@ class SqueakAdminServerHandler(object): ) ) squeak_entries_with_profile = ( - self.squeak_node.get_ancestor_squeak_entries_with_profile( + self.squeak_controller.get_ancestor_squeak_entries_with_profile( squeak_hash, ) ) @@ -271,7 +271,7 @@ class SqueakAdminServerHandler(object): def handle_delete_squeak(self, request): squeak_hash = request.squeak_hash logger.info("Handle delete squeak with hash: {}".format(squeak_hash)) - self.squeak_node.delete_squeak(squeak_hash) + self.squeak_controller.delete_squeak(squeak_hash) logger.info("Deleted squeak entry with hash: {}".format(squeak_hash)) return squeak_admin_pb2.DeleteSqueakReply() @@ -286,7 +286,7 @@ class SqueakAdminServerHandler(object): port, ) ) - peer_id = self.squeak_node.create_peer( + peer_id = self.squeak_controller.create_peer( peer_name, host, port, @@ -298,7 +298,7 @@ class SqueakAdminServerHandler(object): def handle_get_squeak_peer(self, request): peer_id = request.peer_id logger.info("Handle get squeak peer with id: {}".format(peer_id)) - squeak_peer = self.squeak_node.get_peer(peer_id) + squeak_peer = self.squeak_controller.get_peer(peer_id) if squeak_peer is None: return None squeak_peer_msg = squeak_peer_to_message(squeak_peer) @@ -308,7 +308,7 @@ class SqueakAdminServerHandler(object): def handle_get_squeak_peers(self, request): logger.info("Handle get squeak peers") - squeak_peers = self.squeak_node.get_peers() + squeak_peers = self.squeak_controller.get_peers() squeak_peer_msgs = [ squeak_peer_to_message(squeak_peer) for squeak_peer in squeak_peers @@ -326,7 +326,7 @@ class SqueakAdminServerHandler(object): downloading, ) ) - self.squeak_node.set_peer_downloading(peer_id, downloading) + self.squeak_controller.set_peer_downloading(peer_id, downloading) return squeak_admin_pb2.SetPeerDownloadingReply() def handle_set_squeak_peer_uploading(self, request): @@ -338,19 +338,19 @@ class SqueakAdminServerHandler(object): uploading, ) ) - self.squeak_node.set_peer_uploading(peer_id, uploading) + self.squeak_controller.set_peer_uploading(peer_id, uploading) return squeak_admin_pb2.SetPeerUploadingReply() def handle_delete_squeak_peer(self, request): peer_id = request.peer_id logger.info("Handle delete squeak peer with id: {}".format(peer_id)) - self.squeak_node.delete_peer(peer_id) + self.squeak_controller.delete_peer(peer_id) return squeak_admin_pb2.DeletePeerReply() def handle_get_buy_offers(self, request): squeak_hash = request.squeak_hash logger.info("Handle get buy offers for hash: {}".format(squeak_hash)) - offers = self.squeak_node.get_buy_offers_with_peer(squeak_hash) + offers = self.squeak_controller.get_buy_offers_with_peer(squeak_hash) offer_msgs = [offer_entry_to_message(offer) for offer in offers] return squeak_admin_pb2.GetBuyOffersReply( offers=offer_msgs, @@ -359,7 +359,7 @@ class SqueakAdminServerHandler(object): def handle_get_buy_offer(self, request): offer_id = request.offer_id logger.info("Handle get buy offer for hash: {}".format(offer_id)) - offer = self.squeak_node.get_buy_offer_with_peer(offer_id) + offer = self.squeak_controller.get_buy_offer_with_peer(offer_id) offer_msg = offer_entry_to_message(offer) return squeak_admin_pb2.GetBuyOfferReply( offer=offer_msg, @@ -367,7 +367,7 @@ class SqueakAdminServerHandler(object): def handle_sync_squeaks(self, request): logger.info("Handle sync squeaks") - sync_result = self.squeak_node.sync_squeaks() + sync_result = self.squeak_controller.sync_squeaks() sync_result_msg = sync_result_to_message(sync_result) return squeak_admin_pb2.SyncSqueaksReply( sync_result=sync_result_msg, @@ -376,7 +376,7 @@ class SqueakAdminServerHandler(object): def handle_sync_squeak(self, request): squeak_hash = request.squeak_hash logger.info("Handle download squeak with hash: {}".format(squeak_hash)) - sync_result = self.squeak_node.sync_squeak(squeak_hash) + sync_result = self.squeak_controller.sync_squeak(squeak_hash) sync_result_msg = sync_result_to_message(sync_result) return squeak_admin_pb2.SyncSqueakReply( sync_result=sync_result_msg, @@ -385,14 +385,14 @@ class SqueakAdminServerHandler(object): def handle_pay_offer(self, request): offer_id = request.offer_id logger.info("Handle pay offer for offer id: {}".format(offer_id)) - sent_payment_id = self.squeak_node.pay_offer(offer_id) + sent_payment_id = self.squeak_controller.pay_offer(offer_id) return squeak_admin_pb2.PayOfferReply( sent_payment_id=sent_payment_id, ) def handle_get_sent_payments(self, request): logger.info("Handle get sent payments") - sent_payments = self.squeak_node.get_sent_payments() + sent_payments = self.squeak_controller.get_sent_payments() sent_payment_msgs = [sent_payment_with_peer_to_message(sent_payment) for sent_payment in sent_payments] return squeak_admin_pb2.GetSentPaymentsReply( sent_payments=sent_payment_msgs, @@ -401,7 +401,7 @@ class SqueakAdminServerHandler(object): def handle_get_sent_payment(self, request): sent_payment_id = request.sent_payment_id logger.info("Handle get sent payment with id: {}".format(sent_payment_id)) - sent_payment = self.squeak_node.get_sent_payment(sent_payment_id) + sent_payment = self.squeak_controller.get_sent_payment(sent_payment_id) sent_payment_msg = sent_payment_with_peer_to_message(sent_payment) return squeak_admin_pb2.GetSentPaymentReply( sent_payment=sent_payment_msg, @@ -410,7 +410,7 @@ class SqueakAdminServerHandler(object): def handle_get_squeak_details(self, request): squeak_hash = request.squeak_hash logger.info("Handle get squeak details for hash: {}".format(squeak_hash)) - squeak_entry_with_profile = self.squeak_node.get_squeak_entry_with_profile( + squeak_entry_with_profile = self.squeak_controller.get_squeak_entry_with_profile( squeak_hash ) detail_message = squeak_entry_to_detail_message(squeak_entry_with_profile) @@ -420,7 +420,7 @@ class SqueakAdminServerHandler(object): def handle_get_sent_offers(self, request): logger.info("Handle get sent offers") - sent_offers = self.squeak_node.get_sent_offers() + sent_offers = self.squeak_controller.get_sent_offers() sent_offer_msgs = [sent_offer_to_message(sent_offer) for sent_offer in sent_offers] return squeak_admin_pb2.GetSentOffersReply( sent_offers=sent_offer_msgs, @@ -428,7 +428,7 @@ class SqueakAdminServerHandler(object): def handle_get_received_payments(self, request): logger.info("Handle get received payments") - received_payments = self.squeak_node.get_received_payments() + received_payments = self.squeak_controller.get_received_payments() received_payment_msgs = [received_payments_to_message(received_payment) for received_payment in received_payments] return squeak_admin_pb2.GetReceivedPaymentsReply( received_payments=received_payment_msgs, diff --git a/squeaknode/main.py b/squeaknode/main.py index f8d74475..1d33dee7 100644 --- a/squeaknode/main.py +++ b/squeaknode/main.py @@ -15,10 +15,11 @@ from squeaknode.bitcoin.bitcoin_blockchain_client import BitcoinBlockchainClient from squeaknode.lightning.lnd_lightning_client import LNDLightningClient from squeaknode.db.db_engine import get_engine, get_sqlite_connection_string from squeaknode.db.squeak_db import SqueakDb -from squeaknode.node.squeak_node import SqueakNode +from squeaknode.node.squeak_controller import SqueakController from squeaknode.server.lightning_address import LightningAddressHostPort from squeaknode.server.squeak_server_handler import SqueakServerHandler from squeaknode.server.squeak_server_servicer import SqueakServerServicer +from squeaknode.node.squeak_node import SqueakNode from squeaknode.config.config import Config @@ -91,14 +92,14 @@ def load_sync_interval_s(config): return config.squeaknode_sync_interval_s -def load_handler(squeak_node): - return SqueakServerHandler(squeak_node) +def load_handler(squeak_controller): + return SqueakServerHandler(squeak_controller) -def load_admin_handler(lightning_client, squeak_node): +def load_admin_handler(lightning_client, squeak_controller): return SqueakAdminServerHandler( lightning_client, - squeak_node, + squeak_controller, ) @@ -224,20 +225,21 @@ def run_server(config): # load enable sync config sync_interval_s = load_sync_interval_s(config) - # Create and start the squeak node - squeak_node = SqueakNode( + squeak_controller = SqueakController( squeak_db, blockchain_client, lightning_client, lightning_host_port, price_msat, max_squeaks_per_address_per_hour, - sync_interval_s, ) + + # Create and start the squeak node + squeak_node = SqueakNode(squeak_controller, sync_interval_s) squeak_node.start_running() # start admin rpc server - admin_handler = load_admin_handler(lightning_client, squeak_node) + admin_handler = load_admin_handler(lightning_client, squeak_controller) admin_rpc_server = load_admin_rpc_server(config, admin_handler) start_admin_rpc_server(admin_rpc_server) @@ -248,7 +250,7 @@ def run_server(config): start_admin_web_server(admin_web_server) # start rpc server - handler = load_handler(squeak_node) + handler = load_handler(squeak_controller) server = load_rpc_server(config, handler) server.serve() diff --git a/squeaknode/node/sent_offers_worker.py b/squeaknode/node/sent_offers_worker.py index 18b06c2a..0a9b0b1d 100644 --- a/squeaknode/node/sent_offers_worker.py +++ b/squeaknode/node/sent_offers_worker.py @@ -5,11 +5,11 @@ logger = logging.getLogger(__name__) class SentOffersWorker: - def __init__(self, sent_offers_verifier): - self.sent_offers_verifier = sent_offers_verifier + def __init__(self, squeak_controller): + self.squeak_controller = squeak_controller def start_running(self): threading.Thread(target=self.process_subscribed_invoices, daemon=True).start() def process_subscribed_invoices(self): - self.sent_offers_verifier.process_subscribed_invoices() + self.squeak_controller.process_subscribed_invoices() diff --git a/squeaknode/node/squeak_block_periodic_worker.py b/squeaknode/node/squeak_block_periodic_worker.py index 13882684..e3a9a145 100644 --- a/squeaknode/node/squeak_block_periodic_worker.py +++ b/squeaknode/node/squeak_block_periodic_worker.py @@ -8,9 +8,9 @@ VERIFY_UPDATE_INTERVAL_S = 60.0 class SqueakBlockPeriodicWorker: - def __init__(self, squeak_block_verifier): - self.squeak_block_verifier = squeak_block_verifier + def __init__(self, squeak_controller): + self.squeak_controller = squeak_controller def start_running(self): threading.Timer(VERIFY_UPDATE_INTERVAL_S, self.start_running).start() - self.squeak_block_verifier.verify_all_unverified_squeaks() + self.squeak_controller.verify_all_unverified_squeaks() diff --git a/squeaknode/node/squeak_block_queue_worker.py b/squeaknode/node/squeak_block_queue_worker.py index 8d0a0add..2551ce7d 100644 --- a/squeaknode/node/squeak_block_queue_worker.py +++ b/squeaknode/node/squeak_block_queue_worker.py @@ -5,11 +5,11 @@ logger = logging.getLogger(__name__) class SqueakBlockQueueWorker: - def __init__(self, squeak_block_verifier): - self.squeak_block_verifier = squeak_block_verifier + def __init__(self, squeak_controller): + self.squeak_controller = squeak_controller def start_running(self): threading.Thread(target=self.process_queue, daemon=True).start() def process_queue(self): - self.squeak_block_verifier.verify_from_queue() + self.squeak_controller.verify_from_queue() diff --git a/squeaknode/node/squeak_controller.py b/squeaknode/node/squeak_controller.py new file mode 100644 index 00000000..1a547a80 --- /dev/null +++ b/squeaknode/node/squeak_controller.py @@ -0,0 +1,361 @@ +import logging +from hashlib import sha256 + +from squeak.core.encryption import ( + CEncryptedDecryptionKey, + generate_initialization_vector, +) +from squeak.core.signing import CSigningKey, CSqueakAddress +from squeak.core import CheckSqueak + +from squeaknode.core.squeak_address_validator import SqueakAddressValidator +from squeaknode.node.squeak_block_verifier import SqueakBlockVerifier +from squeaknode.node.squeak_maker import SqueakMaker +from squeaknode.node.squeak_rate_limiter import SqueakRateLimiter +from squeaknode.node.squeak_store import SqueakStore +from squeaknode.node.squeak_sync_status import SqueakSyncController +from squeaknode.node.squeak_whitelist import SqueakWhitelist +from squeaknode.server.buy_offer import BuyOffer +from squeaknode.server.sent_offer import SentOffer +from squeaknode.server.squeak_peer import SqueakPeer +from squeaknode.server.squeak_profile import SqueakProfile +from squeaknode.server.sent_payment import SentPayment +from squeaknode.server.util import generate_offer_preimage +from squeaknode.node.sent_offers_verifier import SentOffersVerifier +from squeaknode.node.sent_offers_worker import SentOffersWorker + + +logger = logging.getLogger(__name__) + + +class SqueakController: + def __init__( + self, + squeak_db, + blockchain_client, + lightning_client, + lightning_host_port, + price_msat, + max_squeaks_per_address_per_hour, + ): + self.squeak_db = squeak_db + self.blockchain_client = blockchain_client + self.lightning_client = lightning_client + self.lightning_host_port = lightning_host_port + self.price_msat = price_msat + self.squeak_block_verifier = SqueakBlockVerifier(squeak_db, blockchain_client) + self.squeak_rate_limiter = SqueakRateLimiter( + squeak_db, + blockchain_client, + lightning_client, + max_squeaks_per_address_per_hour, + ) + self.squeak_whitelist = SqueakWhitelist( + squeak_db, + ) + self.squeak_store = SqueakStore( + squeak_db, + self.squeak_block_verifier, + self.squeak_rate_limiter, + self.squeak_whitelist, + ) + self.squeak_sync_controller = SqueakSyncController( + self.blockchain_client, + self.squeak_store, + self.squeak_db, + self.lightning_client, + ) + self.sent_offers_verifier = SentOffersVerifier( + self.squeak_db, + self.lightning_client, + ) + + # def start_running(self): + # self.squeak_block_periodic_worker.start_running() + # self.squeak_block_queue_worker.start_running() + # self.squeak_peer_sync_worker.start_running() + # self.squeak_offer_expiry_worker.start_running() + # self.sent_offers_worker.start_running() + + def save_uploaded_squeak(self, squeak): + return self.squeak_store.save_squeak(squeak) + + def save_created_squeak(self, squeak): + return self.squeak_store.save_squeak(squeak, verify=True, skip_whitelist_check=True) + + def get_public_squeak(self, squeak_hash): + return self.squeak_store.get_squeak(squeak_hash, clear_decryption_key=True) + + # def get_squeak_entry(self, squeak_hash): + # return self.squeak_store.get_squeak(squeak_hash) + + def lookup_squeaks(self, addresses, min_block, max_block): + return self.squeak_store.lookup_squeaks(addresses, min_block, max_block) + + def lookup_allowed_addresses(self, addresses): + return self.squeak_whitelist.get_allowed_addresses(addresses) + + def get_buy_offer(self, squeak_hash, challenge, client_addr): + # Get the squeak from the database + squeak = self.squeak_store.get_squeak(squeak_hash) + # Get the decryption key from the squeak + decryption_key = squeak.GetDecryptionKey() + # Solve the proof + proof = decryption_key.decrypt(challenge) + # Generate a new random preimage + preimage = generate_offer_preimage() + # Encrypt the decryption key + iv = generate_initialization_vector() + encrypted_decryption_key = CEncryptedDecryptionKey.from_decryption_key( + decryption_key, preimage, iv + ) + # Create the lightning invoice + add_invoice_response = self.lightning_client.add_invoice(preimage, self.price_msat) + logger.info("add_invoice_response: {}".format(add_invoice_response)) + preimage_hash = add_invoice_response.r_hash + invoice_payment_request = add_invoice_response.payment_request + # invoice_expiry = add_invoice_response.expiry + lookup_invoice_response = self.lightning_client.lookup_invoice(preimage_hash.hex()) + invoice_time = lookup_invoice_response.creation_date + invoice_expiry = lookup_invoice_response.expiry + # Get the lightning network node pubkey + get_info_response = self.lightning_client.get_info() + pubkey = get_info_response.identity_pubkey + # Save the incoming potential payment in the databse. + self.squeak_db.insert_sent_offer( + SentOffer( + sent_offer_id=None, + squeak_hash=squeak_hash, + preimage_hash=preimage_hash.hex(), + price_msat=self.price_msat, + invoice_time=invoice_time, + invoice_expiry=invoice_expiry, + client_addr=client_addr, + ) + ) + # Return the buy offer + return BuyOffer( + squeak_hash, + encrypted_decryption_key, + iv, + self.price_msat, + preimage_hash, + invoice_payment_request, + pubkey, + self.lightning_host_port.host, + self.lightning_host_port.port, + proof, + ) + + def create_signing_profile(self, profile_name): + signing_key = CSigningKey.generate() + verifying_key = signing_key.get_verifying_key() + address = CSqueakAddress.from_verifying_key(verifying_key) + signing_key_str = str(signing_key) + signing_key_bytes = signing_key_str.encode() + squeak_profile = SqueakProfile( + profile_id=None, + profile_name=profile_name, + private_key=signing_key_bytes, + address=str(address), + sharing=False, + following=False, + ) + return self.squeak_db.insert_profile(squeak_profile) + + def create_contact_profile(self, profile_name, squeak_address): + address_validator = SqueakAddressValidator() + if not address_validator.validate(squeak_address): + raise Exception("Invalid squeak address: {}".format(squeak_address)) + squeak_profile = SqueakProfile( + profile_id=None, + profile_name=profile_name, + private_key=None, + address=squeak_address, + sharing=False, + following=False, + ) + return self.squeak_db.insert_profile(squeak_profile) + + def get_signing_profiles(self): + return self.squeak_db.get_signing_profiles() + + def get_contact_profiles(self): + return self.squeak_db.get_contact_profiles() + + def get_squeak_profile(self, profile_id): + return self.squeak_db.get_profile(profile_id) + + def get_squeak_profile_by_address(self, address): + return self.squeak_db.get_profile_by_address(address) + + def get_squeak_profile_by_name(self, name): + return self.squeak_db.get_profile_by_name(name) + + def set_squeak_profile_following(self, profile_id, following): + self.squeak_db.set_profile_following(profile_id, following) + self.squeak_whitelist.refresh() + + def set_squeak_profile_sharing(self, profile_id, sharing): + self.squeak_db.set_profile_sharing(profile_id, sharing) + + def delete_squeak_profile(self, profile_id): + self.squeak_db.delete_profile(profile_id) + + def make_squeak(self, profile_id, content_str, replyto_hash): + squeak_profile = self.squeak_db.get_profile(profile_id) + squeak_maker = SqueakMaker(self.blockchain_client) + squeak = squeak_maker.make_squeak(squeak_profile, content_str, replyto_hash) + return self.save_created_squeak(squeak) + + def get_squeak_entry_with_profile(self, squeak_hash): + return self.squeak_store.get_squeak_entry_with_profile(squeak_hash) + + def get_followed_squeak_entries_with_profile(self): + return self.squeak_store.get_followed_squeak_entries_with_profile() + + def get_squeak_entries_with_profile_for_address( + self, address, min_block, max_block + ): + return self.squeak_store.get_squeak_entries_with_profile_for_address( + address, + min_block, + max_block, + ) + + def get_ancestor_squeak_entries_with_profile(self, squeak_hash_str): + return self.squeak_store.get_ancestor_squeak_entries_with_profile( + squeak_hash_str, + ) + + def delete_squeak(self, squeak_hash): + num_deleted_offers = self.squeak_db.delete_offers_for_squeak(squeak_hash) + logger.info("Deleted number of offers : {}".format(num_deleted_offers)) + return self.squeak_store.delete_squeak(squeak_hash) + + def create_peer(self, peer_name, host, port): + squeak_peer = SqueakPeer( + peer_id=None, + peer_name=peer_name, + host=host, + port=port, + uploading=False, + downloading=False, + ) + return self.squeak_db.insert_peer(squeak_peer) + + def get_peer(self, peer_id): + return self.squeak_db.get_peer(peer_id) + + def get_peers(self): + return self.squeak_db.get_peers() + + def set_peer_downloading(self, peer_id, downloading): + self.squeak_db.set_peer_downloading(peer_id, downloading) + + def set_peer_uploading(self, peer_id, uploading): + self.squeak_db.set_peer_uploading(peer_id, uploading) + + def delete_peer(self, peer_id): + self.squeak_db.delete_peer(peer_id) + + def get_buy_offers_with_peer(self, squeak_hash): + return self.squeak_db.get_offers_with_peer(squeak_hash) + + def get_buy_offer_with_peer(self, offer_id): + return self.squeak_db.get_offer_with_peer(offer_id) + + def pay_offer(self, offer_id): + # Get the offer from the database + offer_with_peer = self.squeak_db.get_offer_with_peer(offer_id) + offer = offer_with_peer.offer + + # Pay the invoice + payment = self.lightning_client.pay_invoice_sync(offer.payment_request) + preimage = payment.payment_preimage + + if not preimage: + raise Exception("Payment failed with error: {}".format(payment.payment_error)) + + # Check if preimage is valid + preimage_hash = sha256(preimage).hexdigest() + is_valid_preimage = (preimage_hash == offer.payment_hash) + + # Save the preimage of the sent payment + sent_payment = SentPayment( + sent_payment_id=None, + offer_id=offer_id, + peer_id=offer.peer_id, + squeak_hash=offer.squeak_hash, + preimage_hash=offer.payment_hash, + preimage=preimage.hex(), + price_msat=offer.price_msat, + node_pubkey=offer.destination, + preimage_is_valid=is_valid_preimage, + time_ms=None, + ) + sent_payment_id = self.squeak_db.insert_sent_payment(sent_payment) + + if is_valid_preimage: + self.unlock_squeak(offer, preimage) + + return sent_payment_id + + def unlock_squeak(self, offer, preimage): + squeak_entry = self.squeak_db.get_squeak_entry(offer.squeak_hash) + squeak = squeak_entry.squeak + + # Verify with the payment preimage and decryption key ciphertext + decryption_key_cipher_bytes = offer.key_cipher + iv = offer.iv + encrypted_decryption_key = CEncryptedDecryptionKey.from_bytes( + decryption_key_cipher_bytes + ) + + # Decrypt the decryption key + decryption_key = encrypted_decryption_key.get_decryption_key(preimage, iv) + serialized_decryption_key = decryption_key.get_bytes() + + # Check the decryption key + squeak.SetDecryptionKey(serialized_decryption_key) + CheckSqueak(squeak) + + # Set the decryption key in the database + self.squeak_store.unlock_squeak( + offer.squeak_hash, + serialized_decryption_key, + ) + + def sync_squeaks(self): + return self.squeak_sync_controller.sync_timeline() + + def sync_squeak(self, squeak_hash): + peers = self.squeak_db.get_peers() + return self.squeak_sync_controller.sync_single_squeak(squeak_hash, peers) + + def get_sent_payments(self): + return self.squeak_db.get_sent_payments() + + def get_sent_payment(self, sent_payment_id): + return self.squeak_db.get_sent_payment(sent_payment_id) + + def get_sent_offers(self): + return self.squeak_db.get_sent_offers() + + def get_received_payments(self): + return self.squeak_db.get_received_payments() + + def delete_all_expired_offers(self): + logger.debug("Deleting expired offers.") + num_expired_offers = self.squeak_db.delete_expired_offers() + if num_expired_offers > 0: + logger.info("Deleted number of offers: {}".format(num_expired_offers)) + + def verify_all_unverified_squeaks(self): + self.squeak_block_verifier.verify_all_unverified_squeaks() + + def verify_from_queue(self): + self.squeak_block_verifier.verify_from_queue() + + def process_subscribed_invoices(self): + self.sent_offers_verifier.process_subscribed_invoices() diff --git a/squeaknode/node/squeak_expired_offer_cleaner.py b/squeaknode/node/squeak_expired_offer_cleaner.py index 7fa465d0..e4d81267 100644 --- a/squeaknode/node/squeak_expired_offer_cleaner.py +++ b/squeaknode/node/squeak_expired_offer_cleaner.py @@ -1,14 +1,11 @@ -import logging +# import logging -logger = logging.getLogger(__name__) +# logger = logging.getLogger(__name__) -class SqueakExpiredOfferCleaner: - def __init__(self, squeak_db): - self.squeak_db = squeak_db +# class SqueakExpiredOfferCleaner: +# def __init__(self, squeak_controller): +# self.squeak_controller = squeak_controller - def delete_all_expired_offers(self): - logger.debug("Deleting expired offers.") - num_expired_offers = self.squeak_db.delete_expired_offers() - if num_expired_offers > 0: - logger.info("Deleted number of offers: {}".format(num_expired_offers)) +# def delete_all_expired_offers(self): +# self.squeak_controller.delete_all_expired_offers() diff --git a/squeaknode/node/squeak_node.py b/squeaknode/node/squeak_node.py index dbaaae3a..972c35ea 100644 --- a/squeaknode/node/squeak_node.py +++ b/squeaknode/node/squeak_node.py @@ -8,25 +8,11 @@ from squeak.core.encryption import ( from squeak.core.signing import CSigningKey, CSqueakAddress from squeak.core import CheckSqueak -from squeaknode.core.squeak_address_validator import SqueakAddressValidator +from squeaknode.node.squeak_controller import SqueakController from squeaknode.node.squeak_block_periodic_worker import SqueakBlockPeriodicWorker from squeaknode.node.squeak_block_queue_worker import SqueakBlockQueueWorker -from squeaknode.node.squeak_block_verifier import SqueakBlockVerifier -from squeaknode.node.squeak_expired_offer_cleaner import SqueakExpiredOfferCleaner -from squeaknode.node.squeak_maker import SqueakMaker -from squeaknode.node.squeak_offer_expiry_worker import SqueakOfferExpiryWorker from squeaknode.node.squeak_peer_sync_worker import SqueakPeerSyncWorker -from squeaknode.node.squeak_rate_limiter import SqueakRateLimiter -from squeaknode.node.squeak_store import SqueakStore -from squeaknode.node.squeak_sync_status import SqueakSyncController -from squeaknode.node.squeak_whitelist import SqueakWhitelist -from squeaknode.server.buy_offer import BuyOffer -from squeaknode.server.sent_offer import SentOffer -from squeaknode.server.squeak_peer import SqueakPeer -from squeaknode.server.squeak_profile import SqueakProfile -from squeaknode.server.sent_payment import SentPayment -from squeaknode.server.util import generate_offer_preimage -from squeaknode.node.sent_offers_verifier import SentOffersVerifier +from squeaknode.node.squeak_offer_expiry_worker import SqueakOfferExpiryWorker from squeaknode.node.sent_offers_worker import SentOffersWorker @@ -36,64 +22,25 @@ logger = logging.getLogger(__name__) class SqueakNode: def __init__( self, - squeak_db, - blockchain_client, - lightning_client, - lightning_host_port, - price_msat, - max_squeaks_per_address_per_hour, + squeak_controller, sync_interval_s, ): - self.squeak_db = squeak_db - self.blockchain_client = blockchain_client - self.lightning_client = lightning_client - self.lightning_host_port = lightning_host_port - self.price_msat = price_msat - self.sync_interval_s = sync_interval_s - self.squeak_block_verifier = SqueakBlockVerifier(squeak_db, blockchain_client) + self.squeak_controller = squeak_controller self.squeak_block_periodic_worker = SqueakBlockPeriodicWorker( - self.squeak_block_verifier + self.squeak_controller, ) self.squeak_block_queue_worker = SqueakBlockQueueWorker( - self.squeak_block_verifier - ) - self.squeak_rate_limiter = SqueakRateLimiter( - squeak_db, - blockchain_client, - lightning_client, - max_squeaks_per_address_per_hour, - ) - self.squeak_whitelist = SqueakWhitelist( - squeak_db, - ) - self.squeak_store = SqueakStore( - squeak_db, - self.squeak_block_verifier, - self.squeak_rate_limiter, - self.squeak_whitelist, - ) - self.squeak_sync_controller = SqueakSyncController( - self.blockchain_client, - self.squeak_store, - self.squeak_db, - self.lightning_client, + self.squeak_controller, ) self.squeak_peer_sync_worker = SqueakPeerSyncWorker( - self.squeak_sync_controller, - self.sync_interval_s, - ) - self.squeak_expired_offer_cleaner = SqueakExpiredOfferCleaner( - self.squeak_db, + self.squeak_controller, + sync_interval_s, ) self.squeak_offer_expiry_worker = SqueakOfferExpiryWorker( - self.squeak_expired_offer_cleaner, - ) - self.sent_offers_verifier = SentOffersVerifier( - self.squeak_db, - self.lightning_client, + self.squeak_controller, ) self.sent_offers_worker = SentOffersWorker( - self.sent_offers_verifier, + self.squeak_controller, ) def start_running(self): @@ -102,271 +49,3 @@ class SqueakNode: self.squeak_peer_sync_worker.start_running() self.squeak_offer_expiry_worker.start_running() self.sent_offers_worker.start_running() - - def save_uploaded_squeak(self, squeak): - return self.squeak_store.save_squeak(squeak) - - def save_created_squeak(self, squeak): - return self.squeak_store.save_squeak(squeak, verify=True, skip_whitelist_check=True) - - def get_public_squeak(self, squeak_hash): - return self.squeak_store.get_squeak(squeak_hash, clear_decryption_key=True) - - # def get_squeak_entry(self, squeak_hash): - # return self.squeak_store.get_squeak(squeak_hash) - - def lookup_squeaks(self, addresses, min_block, max_block): - return self.squeak_store.lookup_squeaks(addresses, min_block, max_block) - - def lookup_allowed_addresses(self, addresses): - return self.squeak_whitelist.get_allowed_addresses(addresses) - - def get_buy_offer(self, squeak_hash, challenge, client_addr): - # Get the squeak from the database - squeak = self.squeak_store.get_squeak(squeak_hash) - # Get the decryption key from the squeak - decryption_key = squeak.GetDecryptionKey() - # Solve the proof - proof = decryption_key.decrypt(challenge) - # Generate a new random preimage - preimage = generate_offer_preimage() - # Encrypt the decryption key - iv = generate_initialization_vector() - encrypted_decryption_key = CEncryptedDecryptionKey.from_decryption_key( - decryption_key, preimage, iv - ) - # Create the lightning invoice - add_invoice_response = self.lightning_client.add_invoice(preimage, self.price_msat) - logger.info("add_invoice_response: {}".format(add_invoice_response)) - preimage_hash = add_invoice_response.r_hash - invoice_payment_request = add_invoice_response.payment_request - # invoice_expiry = add_invoice_response.expiry - lookup_invoice_response = self.lightning_client.lookup_invoice(preimage_hash.hex()) - invoice_time = lookup_invoice_response.creation_date - invoice_expiry = lookup_invoice_response.expiry - # Get the lightning network node pubkey - get_info_response = self.lightning_client.get_info() - pubkey = get_info_response.identity_pubkey - # Save the incoming potential payment in the databse. - self.squeak_db.insert_sent_offer( - SentOffer( - sent_offer_id=None, - squeak_hash=squeak_hash, - preimage_hash=preimage_hash.hex(), - price_msat=self.price_msat, - invoice_time=invoice_time, - invoice_expiry=invoice_expiry, - client_addr=client_addr, - ) - ) - # Return the buy offer - return BuyOffer( - squeak_hash, - encrypted_decryption_key, - iv, - self.price_msat, - preimage_hash, - invoice_payment_request, - pubkey, - self.lightning_host_port.host, - self.lightning_host_port.port, - proof, - ) - - def create_signing_profile(self, profile_name): - signing_key = CSigningKey.generate() - verifying_key = signing_key.get_verifying_key() - address = CSqueakAddress.from_verifying_key(verifying_key) - signing_key_str = str(signing_key) - signing_key_bytes = signing_key_str.encode() - squeak_profile = SqueakProfile( - profile_id=None, - profile_name=profile_name, - private_key=signing_key_bytes, - address=str(address), - sharing=False, - following=False, - ) - return self.squeak_db.insert_profile(squeak_profile) - - def create_contact_profile(self, profile_name, squeak_address): - address_validator = SqueakAddressValidator() - if not address_validator.validate(squeak_address): - raise Exception("Invalid squeak address: {}".format(squeak_address)) - squeak_profile = SqueakProfile( - profile_id=None, - profile_name=profile_name, - private_key=None, - address=squeak_address, - sharing=False, - following=False, - ) - return self.squeak_db.insert_profile(squeak_profile) - - def get_signing_profiles(self): - return self.squeak_db.get_signing_profiles() - - def get_contact_profiles(self): - return self.squeak_db.get_contact_profiles() - - def get_squeak_profile(self, profile_id): - return self.squeak_db.get_profile(profile_id) - - def get_squeak_profile_by_address(self, address): - return self.squeak_db.get_profile_by_address(address) - - def get_squeak_profile_by_name(self, name): - return self.squeak_db.get_profile_by_name(name) - - def set_squeak_profile_following(self, profile_id, following): - self.squeak_db.set_profile_following(profile_id, following) - self.squeak_whitelist.refresh() - - def set_squeak_profile_sharing(self, profile_id, sharing): - self.squeak_db.set_profile_sharing(profile_id, sharing) - - def delete_squeak_profile(self, profile_id): - self.squeak_db.delete_profile(profile_id) - - def make_squeak(self, profile_id, content_str, replyto_hash): - squeak_profile = self.squeak_db.get_profile(profile_id) - squeak_maker = SqueakMaker(self.blockchain_client) - squeak = squeak_maker.make_squeak(squeak_profile, content_str, replyto_hash) - return self.save_created_squeak(squeak) - - def get_squeak_entry_with_profile(self, squeak_hash): - return self.squeak_store.get_squeak_entry_with_profile(squeak_hash) - - def get_followed_squeak_entries_with_profile(self): - return self.squeak_store.get_followed_squeak_entries_with_profile() - - def get_squeak_entries_with_profile_for_address( - self, address, min_block, max_block - ): - return self.squeak_store.get_squeak_entries_with_profile_for_address( - address, - min_block, - max_block, - ) - - def get_ancestor_squeak_entries_with_profile(self, squeak_hash_str): - return self.squeak_store.get_ancestor_squeak_entries_with_profile( - squeak_hash_str, - ) - - def delete_squeak(self, squeak_hash): - num_deleted_offers = self.squeak_db.delete_offers_for_squeak(squeak_hash) - logger.info("Deleted number of offers : {}".format(num_deleted_offers)) - return self.squeak_store.delete_squeak(squeak_hash) - - def create_peer(self, peer_name, host, port): - squeak_peer = SqueakPeer( - peer_id=None, - peer_name=peer_name, - host=host, - port=port, - uploading=False, - downloading=False, - ) - return self.squeak_db.insert_peer(squeak_peer) - - def get_peer(self, peer_id): - return self.squeak_db.get_peer(peer_id) - - def get_peers(self): - return self.squeak_db.get_peers() - - def set_peer_downloading(self, peer_id, downloading): - self.squeak_db.set_peer_downloading(peer_id, downloading) - - def set_peer_uploading(self, peer_id, uploading): - self.squeak_db.set_peer_uploading(peer_id, uploading) - - def delete_peer(self, peer_id): - self.squeak_db.delete_peer(peer_id) - - def get_buy_offers_with_peer(self, squeak_hash): - return self.squeak_db.get_offers_with_peer(squeak_hash) - - def get_buy_offer_with_peer(self, offer_id): - return self.squeak_db.get_offer_with_peer(offer_id) - - def pay_offer(self, offer_id): - # Get the offer from the database - offer_with_peer = self.squeak_db.get_offer_with_peer(offer_id) - offer = offer_with_peer.offer - - # Pay the invoice - payment = self.lightning_client.pay_invoice_sync(offer.payment_request) - preimage = payment.payment_preimage - - if not preimage: - raise Exception("Payment failed with error: {}".format(payment.payment_error)) - - # Check if preimage is valid - preimage_hash = sha256(preimage).hexdigest() - is_valid_preimage = (preimage_hash == offer.payment_hash) - - # Save the preimage of the sent payment - sent_payment = SentPayment( - sent_payment_id=None, - offer_id=offer_id, - peer_id=offer.peer_id, - squeak_hash=offer.squeak_hash, - preimage_hash=offer.payment_hash, - preimage=preimage.hex(), - price_msat=offer.price_msat, - node_pubkey=offer.destination, - preimage_is_valid=is_valid_preimage, - time_ms=None, - ) - sent_payment_id = self.squeak_db.insert_sent_payment(sent_payment) - - if is_valid_preimage: - self.unlock_squeak(offer, preimage) - - return sent_payment_id - - def unlock_squeak(self, offer, preimage): - squeak_entry = self.squeak_db.get_squeak_entry(offer.squeak_hash) - squeak = squeak_entry.squeak - - # Verify with the payment preimage and decryption key ciphertext - decryption_key_cipher_bytes = offer.key_cipher - iv = offer.iv - encrypted_decryption_key = CEncryptedDecryptionKey.from_bytes( - decryption_key_cipher_bytes - ) - - # Decrypt the decryption key - decryption_key = encrypted_decryption_key.get_decryption_key(preimage, iv) - serialized_decryption_key = decryption_key.get_bytes() - - # Check the decryption key - squeak.SetDecryptionKey(serialized_decryption_key) - CheckSqueak(squeak) - - # Set the decryption key in the database - self.squeak_store.unlock_squeak( - offer.squeak_hash, - serialized_decryption_key, - ) - - def sync_squeaks(self): - return self.squeak_sync_controller.sync_timeline() - - def sync_squeak(self, squeak_hash): - peers = self.squeak_db.get_peers() - return self.squeak_sync_controller.sync_single_squeak(squeak_hash, peers) - - def get_sent_payments(self): - return self.squeak_db.get_sent_payments() - - def get_sent_payment(self, sent_payment_id): - return self.squeak_db.get_sent_payment(sent_payment_id) - - def get_sent_offers(self): - return self.squeak_db.get_sent_offers() - - def get_received_payments(self): - return self.squeak_db.get_received_payments() diff --git a/squeaknode/node/squeak_offer_expiry_worker.py b/squeaknode/node/squeak_offer_expiry_worker.py index a9a88445..8910547a 100644 --- a/squeaknode/node/squeak_offer_expiry_worker.py +++ b/squeaknode/node/squeak_offer_expiry_worker.py @@ -10,10 +10,10 @@ CLEAN_INTERVAL_S = 10.0 class SqueakOfferExpiryWorker: def __init__( self, - squeak_expired_offer_cleaner, + squeak_controller, clean_interval_s=CLEAN_INTERVAL_S, ): - self.squeak_expired_offer_cleaner = squeak_expired_offer_cleaner + self.squeak_controller = squeak_controller self.clean_interval_s = clean_interval_s def start_running(self): @@ -21,4 +21,4 @@ class SqueakOfferExpiryWorker: self.remove_expired_offers() def remove_expired_offers(self): - self.squeak_expired_offer_cleaner.delete_all_expired_offers() + self.squeak_controller.delete_all_expired_offers() diff --git a/squeaknode/node/squeak_peer_sync_worker.py b/squeaknode/node/squeak_peer_sync_worker.py index ea913fa0..8f1d763c 100644 --- a/squeaknode/node/squeak_peer_sync_worker.py +++ b/squeaknode/node/squeak_peer_sync_worker.py @@ -7,15 +7,15 @@ logger = logging.getLogger(__name__) class SqueakPeerSyncWorker: def __init__( self, - squeak_sync_controller, + squeak_controller, sync_interval_s, ): - self.squeak_sync_controller = squeak_sync_controller + self.squeak_controller = squeak_controller self.sync_interval_s = sync_interval_s def sync_timeline(self): logger.info("Syncing timeline with peers...") - self.squeak_sync_controller.sync_timeline() + self.squeak_controller.sync_squeaks() def start_running(self): if self.sync_interval_s: diff --git a/squeaknode/server/squeak_server_handler.py b/squeaknode/server/squeak_server_handler.py index 2bf5c4dd..629e4c3f 100644 --- a/squeaknode/server/squeak_server_handler.py +++ b/squeaknode/server/squeak_server_handler.py @@ -1,6 +1,6 @@ import logging -from squeaknode.node.squeak_node import SqueakNode +from squeaknode.node.squeak_controller import SqueakController from squeaknode.server.util import get_hash from proto import squeak_server_pb2, squeak_server_pb2_grpc @@ -11,17 +11,17 @@ logger = logging.getLogger(__name__) class SqueakServerHandler(object): """Handles server commands.""" - def __init__(self, squeak_node: SqueakNode): - self.squeak_node = squeak_node + def __init__(self, squeak_controller: SqueakController): + self.squeak_controller = squeak_controller def handle_posted_squeak(self, squeak): logger.info("Handle posted squeak with hash: {}".format(get_hash(squeak))) # Save the squeak - self.squeak_node.save_uploaded_squeak(squeak) + self.squeak_controller.save_uploaded_squeak(squeak) def handle_get_squeak(self, squeak_hash): logger.info("Handle get squeak by hash: {}".format(squeak_hash)) - return self.squeak_node.get_public_squeak(squeak_hash) + return self.squeak_controller.get_public_squeak(squeak_hash) def handle_lookup_squeaks(self, request): addresses = request.addresses @@ -32,9 +32,9 @@ class SqueakServerHandler(object): str(addresses), min_block, max_block ) ) - hashes = self.squeak_node.lookup_squeaks(addresses, min_block, max_block) + hashes = self.squeak_controller.lookup_squeaks(addresses, min_block, max_block) logger.info("Got number of hashes from db: {}".format(len(hashes))) - allowed_addresses = self.squeak_node.lookup_allowed_addresses(addresses) + allowed_addresses = self.squeak_controller.lookup_allowed_addresses(addresses) logger.info("Got number of allowed addresses from db: {}".format(len(allowed_addresses))) return squeak_server_pb2.LookupSqueaksReply( hashes=hashes, @@ -43,5 +43,5 @@ class SqueakServerHandler(object): def handle_buy_squeak(self, squeak_hash, challenge, client_addr): logger.info("Handle buy squeak by hash: {} from client_addr: {}".format(squeak_hash, client_addr)) - buy_offer = self.squeak_node.get_buy_offer(squeak_hash, challenge, client_addr) + buy_offer = self.squeak_controller.get_buy_offer(squeak_hash, challenge, client_addr) return buy_offer