diff --git a/src/client.ini b/src/client.ini
index 0725142..23e21d2 100644
--- a/src/client.ini
+++ b/src/client.ini
@@ -1,3 +1,3 @@
 [settings]
-server_address = 10.20.127.226:8000
+server_address = 10.20.14.232:8000
 version = 1.0
diff --git a/src/client.py b/src/client.py
index 6ace678..210965d 100644
--- a/src/client.py
+++ b/src/client.py
@@ -17,6 +17,7 @@ async def lifespan(app: FastAPI):
     yield
     clean_env()
 
+
 app = FastAPI(lifespan=lifespan)
 
 
@@ -25,7 +26,7 @@ def init():
     init_db()
     pk, sk = GenerateKeyPair()
     init_config()
-    get_node_list(6, server_address)  # type: ignore
+    get_node_list(2, server_address)  # type: ignore
 
 
 def init_db():
@@ -93,6 +94,7 @@ class C(BaseModel):
     Tuple: Tuple[capsule, int]
     ip: str
 
+
 # receive messages from node
 @app.post("/receive_messages")
 async def receive_messages(message: C):
@@ -170,12 +172,9 @@ async def check_merge(db, ct: int, ip: str):
 
 
 # send message to node
-async def send_messages(node_ips: tuple[str, ...], 
-                        message: bytes, 
-                        dest_ip: str, 
-                        pk_B: point,
-                        shreshold: int
-                        ):
+async def send_messages(
+    node_ips: tuple[str, ...], message: bytes, dest_ip: str, pk_B: point, shreshold: int
+):
     global pk, sk
     id_list = []
     for node_ip in node_ips:
@@ -184,14 +183,14 @@ async def send_messages(node_ips: tuple[str, ...],
         for i in range(4):
             id += int(ip_parts[i]) << (24 - (8 * i))
         id_list.append(id)
-    rk_list = GenerateReKey(sk, pk_B, len(node_ips), shreshold, tuple(id_list)) # type: ignore
+    rk_list = GenerateReKey(sk, pk_B, len(node_ips), shreshold, tuple(id_list))  # type: ignore
     for i in range(len(node_ips)):
         url = "http://" + node_ips[i] + ":8001" + "/recieve_message"
         payload = {
             "source_ip": local_ip,
             "dest_ip": dest_ip,
             "message": message,
-            "rk": rk_list[i]
+            "rk": rk_list[i],
         }
         response = requests.post(url, json=payload)
     return 0
@@ -203,6 +202,7 @@ class IP_Message(BaseModel):
     source_ip: str
     pk: int
 
+
 # request message from others
 @app.post("/request_message")
 async def request_message(i_m: IP_Message):
@@ -212,11 +212,12 @@ async def request_message(i_m: IP_Message):
     source_ip = get_own_ip()
     dest_port = "8003"
     url = "http://" + dest_ip + dest_port + "/recieve_request"
-    payload = {"dest_ip": dest_ip, 
-               "message_name": message_name, 
-               "source_ip": source_ip,
-               "pk": pk
-               }
+    payload = {
+        "dest_ip": dest_ip,
+        "message_name": message_name,
+        "source_ip": source_ip,
+        "pk": pk,
+    }
     response = requests.post(url, json=payload)
     if response.status_code == 200:
         data = response.json()
@@ -224,7 +225,7 @@ async def request_message(i_m: IP_Message):
         threshold = int(data["threshold"])
         with sqlite3.connect("client.db") as db:
             db.execute(
-        """
+                """
         INSERT INTO senderinfo
         (public_key, threshold)
         VALUES
@@ -255,17 +256,20 @@ async def recieve_request(i_m: IP_Message):
     threshold = random.randrange(1, 6)
     own_public_key = pk
     pk_B = i_m.pk
-    
+
     with sqlite3.connect("client.db") as db:
-        cursor = db.execute("""
+        cursor = db.execute(
+            """
                    SELECT nodeip
                    FROM node
                    LIMIT ?
-                   """,(threshold,))
+                   """,
+            (threshold,),
+        )
         node_ips = cursor.fetchall()
     message = b"hello world" + random.randbytes(8)
-    await send_messages(node_ips, message, dest_ip, pk_B, threshold) # type: ignore
-    response = {"threshold": threshold,"public_key": own_public_key}
+    await send_messages(node_ips, message, dest_ip, pk_B, threshold)  # type: ignore
+    response = {"threshold": threshold, "public_key": own_public_key}
     return response
 
 
@@ -303,7 +307,6 @@ def get_node_list(count: int, server_addr: str):
         print("Failed:", response.status_code, response.text)
 
 
-
 pk = point
 sk = int
 server_address = str
@@ -314,4 +317,4 @@ local_ip = get_own_ip()
 if __name__ == "__main__":
     import uvicorn  # pylint: disable=e0401
 
-    uvicorn.run("client:app", host="0.0.0.0", port=8003, reload=True)
+    uvicorn.run("client:app", host="0.0.0.0", port=8002, reload=True)
diff --git a/src/node.py b/src/node.py
index 7178678..2fca97d 100644
--- a/src/node.py
+++ b/src/node.py
@@ -1,4 +1,4 @@
-from fastapi import FastAPI,Request
+from fastapi import FastAPI, Request
 import requests
 from contextlib import asynccontextmanager
 import socket
@@ -6,6 +6,7 @@ import asyncio
 from pydantic import BaseModel
 from tpre import *
 
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Load the ML model
@@ -14,25 +15,28 @@ async def lifespan(app: FastAPI):
     # Clean up the ML models and release the resources
     clear()
 
+
 app = FastAPI(lifespan=lifespan)
-server_address ="http://中心服务器IP地址/server" 
+server_address = "http://中心服务器IP地址/server"
 id = 0
-ip = ''
-client_ip_src = ''   # 发送信息用户的ip
-client_ip_des = ''   # 接收信息用户的ip
-processed_message = ()   # 重加密后的数据
+ip = ""
+client_ip_src = ""  # 发送信息用户的ip
+client_ip_des = ""  # 接收信息用户的ip
+processed_message = ()  # 重加密后的数据
 
 # class C(BaseModel):
 #     Tuple: Tuple[capsule, int]
 #     ip_src: str
 
+
 # 向中心服务器发送自己的IP地址,并获取自己的id
 def send_ip():
-    url = server_address + '/get_node?ip = ' + ip
+    url = server_address + "/get_node?ip = " + ip
     # ip = get_local_ip # type: ignore
     global id
     id = requests.get(url)
 
+
 # 用socket获取本机ip
 def get_local_ip():
     # 创建一个套接字对象
@@ -42,7 +46,7 @@ def get_local_ip():
     # 获取本地IP地址
     local_ip = s.getsockname()[0]
     s.close()
-    global ip 
+    global ip
     ip = local_ip
 
 
@@ -51,52 +55,46 @@ def init():
     global id
     send_ip()
     task = asyncio.create_task(send_heartbeat_internal())
-def clear():
 
+
+def clear():
     pass
 
+
 # 接收用户发来的消息，经过处理之后，再将消息发送给其他用户
 
+
 async def send_heartbeat_internal() -> None:
     while True:
         # print('successful send my_heart')
-        global ip 
-        url = server_address + '/get_node?ip = ' + ip
+        global ip
+        url = server_address + "/get_node?ip = " + ip
         folderol = requests.get(url)
         timeout = 30
         # 删除超时的节点（假设你有一个异步的数据库操作函数）
         await asyncio.sleep(timeout)
 
 
-
-@app.post("/user_src")    # 接收用户1发送的信息
+@app.post("/user_src")  # 接收用户1发送的信息
 async def receive_user_src_message(message: Request):
     json_data = await message.json()
-    global client_ip_src,client_ip_des
+    global client_ip_src, client_ip_des
     # kfrag , capsule_ct ,client_ip_src , client_ip_des   = json_data[]  # 看梁俊勇
     global processed_message
-    processed_message =  ReEncrypt(kfrag, capsule_ct)
+    processed_message = ReEncrypt(kfrag, capsule_ct)
 
 
+def send_user_des_message():  # 发送消息给用户2
+    global processed_message, client_ip_src, client_ip_des
 
-def send_user_des_message():   # 发送消息给用户2
-    global processed_message,client_ip_src,client_ip_des
+    data = {"Tuple": processed_message, "ip": client_ip_src}  # 类型不匹配
 
-    data = {
-    "Tuple": processed_message,   # 类型不匹配
-    "ip": client_ip_src
-}
-    
-# 发送 HTTP POST 请求
-    response = requests.post("http://"+ client_ip_des + "/receive_messages", json=data)
+    # 发送 HTTP POST 请求
+    response = requests.post("http://" + client_ip_des + "/receive_messages", json=data)
     print(response)
 
 
 if __name__ == "__main__":
     import uvicorn  # pylint: disable=e0401
 
-    uvicorn.run("node:app", host="0.0.0.0", port=8000, reload=True)
-
-
-
-
+    uvicorn.run("node:app", host="0.0.0.0", port=8001, reload=True)