def main(): # Due to updated ECDSA generated tls.cert we need to let gprc know that # we need to use that cipher suite otherwise there will be a handhsake # error when we communicate with the lnd rpc server. os.environ["GRPC_SSL_CIPHER_SUITES"] = 'HIGH+ECDSA' start_spy_output = cmd(start_spy[0]) # open gRPC connection cert = open(os.path.expanduser('~/.lnd/tls.cert'), 'rb').read() creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel('localhost:10002', creds) stub = lnrpc.WalletUnlockerStub(channel) # unlock wallet # request = ln.UnlockWalletRequest(wallet_password="******".encode()) # response = stub.UnlockWallet(request) for line in start_spy_output: match_r = re.search("((.*)Received UpdateAddHTLC(.*))", line) match_s = re.search("((.*)Sending UpdateAddHTLC(.*))", line) if match_r: from_addr = line.split(' from ')[1].split('@')[0] timestamp = line.split(' [DBG] ')[0] from_amt = line.split(', ')[2].split('=')[1] print(from_addr + ' - ' + from_amt + ' - ' + timestamp) elif match_s: print("asdsad") return
def create_wallet(container): channel = get_channel(container) stub = lnrpc.WalletUnlockerStub(channel) request = ln.InitWalletRequest( wallet_password=PASSWORD.encode(), cipher_seed_mnemonic=gen_seed(container), ) response = stub.InitWallet(request) print(response)
def start(self): super().start() self.wait_for_log('RPC server listening on') self.unlocker_stub = lnrpc_grpc.WalletUnlockerStub(self.make_channel()) seed = self.unlocker_stub.GenSeed(lnrpc.GenSeedRequest()) self.unlocker_stub.InitWallet( lnrpc.InitWalletRequest( wallet_password=b"password", recovery_window=0, cipher_seed_mnemonic=seed.cipher_seed_mnemonic)) self.wait_for_log('Done catching up block hashes') time.sleep(5) # need to remake the channel, otherwise the Lightning gRPC service might not be there yet self.stub = lnrpc_grpc.LightningStub(self.make_channel()) logging.info('LND started (pid: {})'.format(self.proc.pid))
def main(): if len(sys.argv) < 3: # missing num nodes print("Usage:") print(" py lnd-cluster.py <NUM_NODES> <GRAPH_TYPE> <ROUTING_TYPE>") print(" Graph types: tree, central, ring") print(" Routing types: random, merchant") exit(1) NUM_NODES = int(sys.argv[1]) GRAPH_TYPE = sys.argv[2] ROUTING_TYPE = sys.argv[3] WALLET_PASS = bytes('00000000', 'utf-8') MINNING_ADDR = "SY6RbmrfYo2Vg9P9RuTreucM7G1SyVqhhb" ### ARG Checking ### if GRAPH_TYPE not in graphs.graph_types: print("ERROR: invalid graph type -> " + GRAPH_TYPE) exit() if ROUTING_TYPE not in routing.routing_types: print("ERROR: invalid routing type -> " + ROUTING_TYPE) exit() ### Create BTCD dir ### if os.path.exists(BTCD_DIR) == False: os.makedirs(BTCD_DIR) ### Create Nodes dir ### if os.path.exists(NODES_DIR) == False: os.makedirs(NODES_DIR) ### Clean Nodes dir ### dir_list = os.listdir(NODES_DIR) for node_id in dir_list: node_dir = NODES_DIR + '/' + str(node_id) shutil.rmtree(node_dir) ### Thread data ### # btcd thread proc btcd = None # Stores all node data # { # id, # thread, # stub_wal, # addr # } nodes = [] ### Start Threads ### # start btcd thread btcd = Process(target=btcd_start_node) btcd.start() # start lnd threads for node_id in range(0, NUM_NODES): nodes.append({ "id": node_id, "thread": Process(target=ln_start_node, args=(node_id, )) }) nodes[node_id]["thread"].start() time.sleep(1) os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA' ### init RPC stubs ### for node_id in range(0, NUM_NODES): while True: try: print("Node {} reading cert file...".format(str(node_id))) cert = open(NODES_DIR + '/' + str(node_id) + '/tls.cert', 'rb').read() break except: print("ERROR: cannot find cert file: " + str(NODES_DIR + '/' + str(node_id) + '/tls.cert')) ssl_creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel('localhost:' + str(10000 + node_id), ssl_creds) stub_wal = lnrpc.WalletUnlockerStub(channel) nodes[node_id]["stub_wal"] = stub_wal ### Init a node ### for node_id in range(0, NUM_NODES): stub_wal = nodes[node_id]['stub_wal'] # Gen Seed request = None if node_id == 0: # use same seed for first node # keeps minning address constant request = ln.GenSeedRequest(seed_entropy=bytes(node_seed)) else: request = ln.GenSeedRequest() response = stub_wal.GenSeed(request) cipher_seed_mnemonic = response.cipher_seed_mnemonic print(bytes(node_seed)) print(response) # Init Wallet request = ln.InitWalletRequest( wallet_password=WALLET_PASS, cipher_seed_mnemonic=cipher_seed_mnemonic) response = stub_wal.InitWallet(request) print(response) ### wait for rpc servers to init ### for node_id in range(0, NUM_NODES): while True: output = cmd_async( lncli_cmd.format(str(node_id), str(10000 + node_id), "getinfo")) try: # if rpc server is active, # the response will be json info_output = json.loads(output) nodes[node_id]['id_pubkey'] = info_output["identity_pubkey"] print(info_output) break except: print("======== ERROR: RPC server not active yet ========") print("======== node_id: {} ========". format(node_id)) time.sleep(1) # New Address output = cmd_async( lncli_cmd.format(str(node_id), str(10000 + node_id), "newaddress np2wkh")) nodes[node_id]["addr"] = json.loads(output)["address"] ### Fund All Nodes ### COINS_PER_NODE = " 100000000" output_node_0_balance = cmd_async( lncli_cmd.format("0", "10000", "walletbalance")) print(output_node_0_balance) # Mine coins output_mining = cmd_async(btcctl_cmd.format("generate 200")) time.sleep(5) # Wait for mining # Send Coins for node_id in range(1, NUM_NODES): lnc_command = lncli_cmd.format( "0", "10000", "sendcoins " + nodes[node_id]['addr'] + COINS_PER_NODE) output_sendcoins = cmd_async(lnc_command) print(output_sendcoins) # Mine transactions cmd_async(btcctl_cmd.format("generate 100")) time.sleep(5) # Wait for mining ### Connect Peers and Create Channels ### # create graph graph = graphs.graph_types[GRAPH_TYPE](NUM_NODES) # connect peers and open channels for node_id in range(0, NUM_NODES): peers = graph[node_id] for peer_i in range(0, len(peers)): peer = nodes[peers[peer_i]] # connect peers lnc_command = lncli_cmd.format( str(node_id), str(10000 + node_id), "connect " + peer["id_pubkey"] + "@localhost:" + str(20000 + peer['id'])) output_connect = cmd_async(lnc_command) print(output_connect) # open channels lnc_command = lncli_cmd.format( str(node_id), str(10000 + node_id), "openchannel --node_key=" + peer["id_pubkey"] + " --local_amt=1000000 --push_amt=100000") output_channel = cmd_async(lnc_command) print(output_channel) # Mine channels output_mining = cmd_async(btcctl_cmd.format("generate 20")) time.sleep(5) # Wait for mining ### Simulate Routing ### routing.routing_types[ROUTING_TYPE](NUM_NODES) return
return key def encrypt(message: bytes, key: bytes) -> bytes: return Fernet(key).encrypt(message) def decrypt(token: bytes, key: bytes) -> bytes: return Fernet(key).decrypt(token) url = "https://enteryourawsurlhere.com/dev" if __name__ == '__main__': # Send a post request to specified secret URL, which responds with the encrypted passphrase wallet_pass_enc = requests.post(url).text.encode("UTF-8") with open(os.path.expanduser("~") + "/atestkey.key", 'rb') as f: mykey = f.read() wallet_pass = decrypt(wallet_pass_enc, mykey) # wallet_pass = bytes(os.environ["LND_PASS"],"UTF-8") os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA' cert = open('/root/.lnd/tls.cert', 'rb').read() ssl_creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel('localhost:10009', ssl_creds) stub = lnrpc.WalletUnlockerStub(channel) # This is not how we should do this long term request = ln.UnlockWalletRequest(wallet_password=wallet_pass) response = stub.UnlockWallet(request) print(response)
def gen_seed(container): channel = get_channel(container) stub = lnrpc.WalletUnlockerStub(channel) request = ln.GenSeedRequest() response = stub.GenSeed(request) return response.cipher_seed_mnemonic