diff --git a/install-package/fpk/docker/ICON.PNG b/install-package/fpk/docker/ICON.PNG
index a6e6108c..7710a523 100644
Binary files a/install-package/fpk/docker/ICON.PNG and b/install-package/fpk/docker/ICON.PNG differ
diff --git a/install-package/fpk/docker/app/ui/images/icon_64.png b/install-package/fpk/docker/app/ui/images/icon_64.png
index a6e6108c..7710a523 100644
Binary files a/install-package/fpk/docker/app/ui/images/icon_64.png and b/install-package/fpk/docker/app/ui/images/icon_64.png differ
diff --git a/shells/version.txt b/shells/version.txt
index d39e268d..c2ac01ab 100644
--- a/shells/version.txt
+++ b/shells/version.txt
@@ -1,5 +1,5 @@
 v1.9.6
-2025-11-27 16:41:58
+2025-11-28 11:00:47
 1. 一些累计更新，一些BUG修复
 2. 优化客户端数据同步，减少服务器流量
 3. 去除cdkey，改为发电解锁中继速度
diff --git a/src/linker.messenger.action/SignInArgsAction.cs b/src/linker.messenger.action/SignInArgsAction.cs
index 1ceddb96..c630e3f1 100644
--- a/src/linker.messenger.action/SignInArgsAction.cs
+++ b/src/linker.messenger.action/SignInArgsAction.cs
@@ -226,7 +226,7 @@ namespace linker.messenger.action
             }
             return string.Empty;
         }
-        public async Task<List<RelayNodeStoreInfo>> Validate(string userid, SignCacheInfo fromMachine, List<RelayNodeStoreInfo> nodes)
+        public async Task<List<RelayServerNodeStoreInfo>> Validate(string userid, SignCacheInfo fromMachine, List<RelayServerNodeStoreInfo> nodes)
         {
             if (string.IsNullOrWhiteSpace(actionServerStore.RelayNodeUrl) == false)
             {
diff --git a/src/linker.messenger.relay/Entry.cs b/src/linker.messenger.relay/Entry.cs
index a7c4e5a8..df12099b 100644
--- a/src/linker.messenger.relay/Entry.cs
+++ b/src/linker.messenger.relay/Entry.cs
@@ -55,6 +55,8 @@ namespace linker.messenger.relay
         {
             serviceCollection.AddSingleton<RelayServerMessenger>();
             serviceCollection.AddSingleton<RelayServerNodeTransfer>();
+            serviceCollection.AddSingleton<RelayServerNodeReportTransfer>();
+            
             serviceCollection.AddSingleton<RelayServerMasterTransfer>();
             serviceCollection.AddSingleton<RelayServerReportResolver>();
             serviceCollection.AddSingleton<RelayServerResolver>();
diff --git a/src/linker.messenger.relay/client/RelayApiController.cs b/src/linker.messenger.relay/client/RelayApiController.cs
index 23b98fdf..7cb5e35e 100644
--- a/src/linker.messenger.relay/client/RelayApiController.cs
+++ b/src/linker.messenger.relay/client/RelayApiController.cs
@@ -33,7 +33,7 @@ namespace linker.messenger.relay.client
             this.tunnelTransfer = tunnelTransfer;
         }
 
-        public List<RelayNodeStoreInfo> Subscribe(ApiControllerParamsInfo param)
+        public List<RelayServerNodeStoreInfo> Subscribe(ApiControllerParamsInfo param)
         {
             relayTestTransfer.Subscribe();
             return relayTestTransfer.Nodes;
diff --git a/src/linker.messenger.relay/client/RelayClientTestTransfer.cs b/src/linker.messenger.relay/client/RelayClientTestTransfer.cs
index d778811e..3abe6765 100644
--- a/src/linker.messenger.relay/client/RelayClientTestTransfer.cs
+++ b/src/linker.messenger.relay/client/RelayClientTestTransfer.cs
@@ -16,7 +16,7 @@ namespace linker.messenger.relay.client
         private readonly TransportRelay transportRelay;
         private readonly SignInClientState signInClientState;
 
-        public List<RelayNodeStoreInfo> Nodes { get; private set; } = new List<RelayNodeStoreInfo>();
+        public List<RelayServerNodeStoreInfo> Nodes { get; private set; } = new List<RelayServerNodeStoreInfo>();
 
         public RelayClientTestTransfer(TransportRelay transportRelay, SignInClientState signInClientState)
         {
diff --git a/src/linker.messenger.relay/messenger/RelayMessenger.cs b/src/linker.messenger.relay/messenger/RelayMessenger.cs
index d54d7f6e..5681eab9 100644
--- a/src/linker.messenger.relay/messenger/RelayMessenger.cs
+++ b/src/linker.messenger.relay/messenger/RelayMessenger.cs
@@ -23,33 +23,34 @@ namespace linker.messenger.relay.messenger
     public class RelayServerMessenger : IMessenger
     {
         private readonly SignInServerCaching signCaching;
-        private readonly RelayServerMasterTransfer relayServerTransfer;
         private readonly RelayServerValidatorTransfer relayValidatorTransfer;
         private readonly ISerializer serializer;
         private readonly RelayServerReportResolver relayServerReportResolver;
-        private readonly IRelayServerNodeStore relayServerNodeStore;
+        private readonly RelayServerNodeTransfer relayServerNodeTransfer;
+        private readonly RelayServerMasterTransfer relayServerMasterTransfer;
 
-        public RelayServerMessenger(SignInServerCaching signCaching, ISerializer serializer,
-            RelayServerMasterTransfer relayServerTransfer, RelayServerValidatorTransfer relayValidatorTransfer,
-            RelayServerReportResolver relayServerReportResolver, IRelayServerNodeStore relayServerNodeStore)
+
+        public RelayServerMessenger(SignInServerCaching signCaching, ISerializer serializer, RelayServerValidatorTransfer relayValidatorTransfer,
+            RelayServerReportResolver relayServerReportResolver, RelayServerNodeTransfer relayServerNodeTransfer, RelayServerMasterTransfer relayServerMasterTransfer)
         {
             this.signCaching = signCaching;
-            this.relayServerTransfer = relayServerTransfer;
             this.relayValidatorTransfer = relayValidatorTransfer;
             this.serializer = serializer;
             this.relayServerReportResolver = relayServerReportResolver;
-            this.relayServerNodeStore = relayServerNodeStore;
+            this.relayServerNodeTransfer = relayServerNodeTransfer;
+            this.relayServerMasterTransfer = relayServerMasterTransfer;
         }
 
+
         [MessengerId((ushort)RelayMessengerIds.Nodes)]
         public async Task Nodes(IConnection connection)
         {
             if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) == false)
             {
-                connection.Write(serializer.Serialize(new List<RelayNodeStoreInfo> { }));
+                connection.Write(serializer.Serialize(new List<RelayServerNodeStoreInfo> { }));
                 return;
             }
-            List<RelayNodeStoreInfo> nodes = await GetNodes(cache);
+            List<RelayServerNodeStoreInfo> nodes = await GetNodes(cache);
             connection.Write(serializer.Serialize(nodes));
         }
 
@@ -66,25 +67,28 @@ namespace linker.messenger.relay.messenger
 
             var nodes = await GetNodes(from).ConfigureAwait(false);
             string error = await relayValidatorTransfer.Validate(from, to, info.transactionId);
-            if (string.IsNullOrWhiteSpace(error) == false || relayServerTransfer.AddRelay(from, to, info.flowId) == false)
+            if (string.IsNullOrWhiteSpace(error) == false || relayServerMasterTransfer.AddRelay(from, to, info.flowId) == false)
             {
                 connection.Write(serializer.Serialize(new RelayAskResultInfo()));
                 return;
             }
 
-            connection.Write(serializer.Serialize(new RelayAskResultInfo { Nodes = nodes, MasterId = relayServerNodeStore.Node.NodeId }));
-        }
-        private async Task<List<RelayNodeStoreInfo>> GetNodes(SignCacheInfo from)
-        {
-            return await relayServerTransfer.GetNodes(from.Super, from.UserId, from.MachineId);
+            connection.Write(serializer.Serialize(new RelayAskResultInfo { Nodes = nodes, MasterId = relayServerNodeTransfer.Node.NodeId }));
         }
 
-        [MessengerId((ushort)RelayMessengerIds.NodeGetCache)]
-        public async Task NodeGetCache(IConnection connection)
+        private async Task<List<RelayServerNodeStoreInfo>> GetNodes(SignCacheInfo from)
+        {
+            return await relayServerMasterTransfer.GetNodes(from.Super, from.UserId, from.MachineId);
+        }
+
+
+
+        [MessengerId((ushort)RelayMessengerIds.GetCache)]
+        public async Task GetCache(IConnection connection)
         {
             relayServerReportResolver.Add(connection.ReceiveRequestWrap.Payload.Length, 0);
             ValueTuple<string, string> key = serializer.Deserialize<ValueTuple<string, string>>(connection.ReceiveRequestWrap.Payload.Span);
-            RelayCacheInfo cache = await relayServerTransfer.TryGetRelayCache(key.Item1, key.Item2);
+            RelayCacheInfo cache = await relayServerMasterTransfer.TryGetRelayCache(key.Item1, key.Item2);
             if (cache != null)
             {
                 byte[] sendt = serializer.Serialize(cache);
@@ -99,12 +103,17 @@ namespace linker.messenger.relay.messenger
 
 
         [MessengerId((ushort)RelayMessengerIds.NodeReport)]
-        public void NodeReport188(IConnection connection)
+        public async Task NodeReport(IConnection connection)
         {
             try
             {
                 relayServerReportResolver.Add(connection.ReceiveRequestWrap.Payload.Length, 0);
                 RelayServerNodeReportInfoOld info = serializer.Deserialize<RelayServerNodeReportInfoOld>(connection.ReceiveRequestWrap.Payload.Span);
+                await relayServerMasterTransfer.AddNode(new RelayServerNodeStoreInfo
+                {
+                    NodeId = info.Id,
+                    Name = info.Name,
+                }).ConfigureAwait(false);
             }
             catch (Exception)
             {
diff --git a/src/linker.messenger.relay/messenger/RelayMessengerIds.cs b/src/linker.messenger.relay/messenger/RelayMessengerIds.cs
index ea5071ca..3f69c9bd 100644
--- a/src/linker.messenger.relay/messenger/RelayMessengerIds.cs
+++ b/src/linker.messenger.relay/messenger/RelayMessengerIds.cs
@@ -8,7 +8,7 @@
 
         Nodes = 2105,
 
-        NodeGetCache = 2112,
+        GetCache = 2112,
         NodeReport = 2128,
 
         Hosts = 2133,
diff --git a/src/linker.messenger.relay/server/IRelayServerNodeStore.cs b/src/linker.messenger.relay/server/IRelayServerConfigStore.cs
similarity index 86%
rename from src/linker.messenger.relay/server/IRelayServerNodeStore.cs
rename to src/linker.messenger.relay/server/IRelayServerConfigStore.cs
index 03103165..bcc8a564 100644
--- a/src/linker.messenger.relay/server/IRelayServerNodeStore.cs
+++ b/src/linker.messenger.relay/server/IRelayServerConfigStore.cs
@@ -1,38 +1,33 @@
-using linker.libs;
-using System.Net;
+using System.Net;
 using linker.libs.extends;
 using System.Text.Json.Serialization;
 using linker.tunnel.connection;
 
 namespace linker.messenger.relay.server
 {
-    public interface IRelayServerNodeStore
+    public interface IRelayServerConfigStore
     {
-        /// <summary>
-        /// 服务端端口
-        /// </summary>
-        public int ServicePort { get; }
         /// <summary>
         /// 节点信息
         /// </summary>
-        public RelayServerNodeInfo Node { get; }
+        public RelayServerConfigInfo Config { get; }
 
         /// <summary>
         /// 设置
         /// </summary>
-        /// <param name="node"></param>
-        public void SetInfo(RelayServerNodeInfo node);
+        /// <param name="config"></param>
+        public void SetInfo(RelayServerConfigInfo config);
 
         /// <summary>
         /// 设置月份
         /// </summary>
         /// <param name="month"></param>
-        public void SetMaxGbTotalMonth(int month);
+        public void DataMonth(int month);
         /// <summary>
         /// 设置剩余流量
         /// </summary>
         /// <param name="value"></param>
-        public void SetMaxGbTotalLastBytes(long value);
+        public void SetDataRemain(long value);
         /// <summary>
         /// 提交保存
         /// </summary>
@@ -58,6 +53,11 @@ namespace linker.messenger.relay.server
         public string Logo { get; set; } = "https://linker.snltty.com/img/logo.png";
     }
 
+    public sealed class RelayServerConfigInfo : RelayServerNodeInfo
+    {
+        public string ShareKey { get; set; } = string.Empty;
+    }
+
     public class RelayServerNodeReportInfo : RelayServerNodeInfo
     {
         public string Version { get; set; } = string.Empty;
diff --git a/src/linker.messenger.relay/server/IRelayServerMasterStore.cs b/src/linker.messenger.relay/server/IRelayServerMasterStore.cs
index 6fd28eab..8ac33cc4 100644
--- a/src/linker.messenger.relay/server/IRelayServerMasterStore.cs
+++ b/src/linker.messenger.relay/server/IRelayServerMasterStore.cs
@@ -1,11 +1,13 @@
 namespace linker.messenger.relay.server
 {
-    public interface IRelayServerMasterStore
+    public interface IRelayServerNodeStore
     {
-        public Task<List<RelayNodeStoreInfo>> GetAll();
+        public Task<List<RelayServerNodeStoreInfo>> GetAll();
+        public Task<RelayServerNodeStoreInfo> GetByNodeId(string nodeId);
+        public Task<bool> Add(RelayServerNodeStoreInfo info);
     }
 
-    public sealed class RelayNodeStoreInfo : RelayServerNodeReportInfo
+    public sealed class RelayServerNodeStoreInfo : RelayServerNodeReportInfo
     {
         public int Id { get; set; }
 
@@ -14,7 +16,5 @@
 
         public int Delay { get; set; }
         public long LastTicks { get; set; }
-
-
     }
 }
diff --git a/src/linker.messenger.relay/server/RelayServerMasterTransfer.cs b/src/linker.messenger.relay/server/RelayServerMasterTransfer.cs
index 4cf12865..c7ab82ed 100644
--- a/src/linker.messenger.relay/server/RelayServerMasterTransfer.cs
+++ b/src/linker.messenger.relay/server/RelayServerMasterTransfer.cs
@@ -10,9 +10,9 @@ namespace linker.messenger.relay.server
     {
         private readonly IRelayServerCaching relayCaching;
         private readonly IRelayServerWhiteListStore relayServerWhiteListStore;
-        private readonly IRelayServerMasterStore relayServerMasterStore;
+        private readonly IRelayServerNodeStore relayServerMasterStore;
 
-        public RelayServerMasterTransfer(IRelayServerCaching relayCaching, IRelayServerWhiteListStore relayServerWhiteListStore, IRelayServerMasterStore relayServerMasterStore)
+        public RelayServerMasterTransfer(IRelayServerCaching relayCaching, IRelayServerWhiteListStore relayServerWhiteListStore, IRelayServerNodeStore relayServerMasterStore)
         {
             this.relayCaching = relayCaching;
             this.relayServerWhiteListStore = relayServerWhiteListStore;
@@ -35,7 +35,6 @@ namespace linker.messenger.relay.server
             };
             return relayCaching.TryAdd($"{cache.FromId}->{cache.ToId}->{flowid}", cache, 15000);
         }
-
         public async Task<RelayCacheInfo> TryGetRelayCache(string key, string nodeid)
         {
             if (relayCaching.TryGetValue(key, out RelayCacheInfo cache))
@@ -54,12 +53,9 @@ namespace linker.messenger.relay.server
             }
             return null;
         }
-        /// <summary>
-        /// 获取节点列表
-        /// </summary>
-        /// <param name="validated">是否已认证</param>
-        /// <returns></returns>
-        public async Task<List<RelayNodeStoreInfo>> GetNodes(bool validated, string userid, string machineId)
+    
+
+        public async Task<List<RelayServerNodeStoreInfo>> GetNodes(bool validated, string userid, string machineId)
         {
             var nodes = (await relayServerWhiteListStore.GetNodes(userid, machineId)).Where(c => c.Bandwidth >= 0).SelectMany(c => c.Nodes);
 
@@ -81,7 +77,7 @@ namespace linker.messenger.relay.server
                      .ThenByDescending(x => x.DataRemain == 0 ? long.MaxValue : x.DataRemain)
                      .ToList();
         }
-        public async Task<List<RelayNodeStoreInfo>> GetPublicNodes()
+        public async Task<List<RelayServerNodeStoreInfo>> GetPublicNodes()
         {
             var result = (await relayServerMasterStore.GetAll())
                 .Where(c => Environment.TickCount64 - c.LastTicks < 15000)
@@ -98,6 +94,10 @@ namespace linker.messenger.relay.server
                      .ToList();
         }
 
+        public async Task<bool> AddNode(RelayServerNodeStoreInfo info)
+        {
+            return await relayServerMasterStore.Add(info).ConfigureAwait(false);
+        }
     }
 
     public sealed partial class RelayCacheInfo
diff --git a/src/linker.messenger.relay/server/RelayServerNodeReportTransfer.cs b/src/linker.messenger.relay/server/RelayServerNodeReportTransfer.cs
new file mode 100644
index 00000000..b46a0a10
--- /dev/null
+++ b/src/linker.messenger.relay/server/RelayServerNodeReportTransfer.cs
@@ -0,0 +1,30 @@
+namespace linker.messenger.relay.server
+{
+    public sealed class RelayServerNodeReportTransfer
+    {
+        private uint connectionNum = 0;
+        private long bytes = 0;
+
+        public uint ConnectionNum => connectionNum;
+
+        /// <summary>
+        /// 增加连接数
+        /// </summary>
+        public void IncrementConnectionNum()
+        {
+            Interlocked.Increment(ref connectionNum);
+        }
+        /// <summary>
+        /// 减少连接数
+        /// </summary>
+        public void DecrementConnectionNum()
+        {
+            Interlocked.Decrement(ref connectionNum);
+        }
+
+        public void AddBytes(long length)
+        {
+            Interlocked.Add(ref bytes, length);
+        }
+    }
+}
diff --git a/src/linker.messenger.relay/server/RelayServerNodeTransfer.cs b/src/linker.messenger.relay/server/RelayServerNodeTransfer.cs
index 043c3875..b0b97a4d 100644
--- a/src/linker.messenger.relay/server/RelayServerNodeTransfer.cs
+++ b/src/linker.messenger.relay/server/RelayServerNodeTransfer.cs
@@ -4,7 +4,6 @@ using linker.messenger.relay.messenger;
 using linker.tunnel.connection;
 using linker.tunnel.transport;
 using System.Collections.Concurrent;
-using System.Net;
 
 namespace linker.messenger.relay.server
 {
@@ -13,31 +12,28 @@ namespace linker.messenger.relay.server
     /// </summary>
     public class RelayServerNodeTransfer
     {
-        /// <summary>
-        /// 配置了就用配置的，每配置就用一个默认的
-        /// </summary>
-        public RelayServerNodeInfo Node => relayServerNodeStore.Node;
+        public RelayServerConfigInfo Node => relayServerNodeStore.Config;
 
-        private uint connectionNum = 0;
 
-        private long bytes = 0;
         private readonly RelaySpeedLimit limitTotal = new RelaySpeedLimit();
         private readonly ConcurrentDictionary<ulong, RelayTrafficCacheInfo> trafficDict = new();
 
         private readonly ISerializer serializer;
-        private readonly IRelayServerNodeStore relayServerNodeStore;
+        private readonly IRelayServerConfigStore relayServerNodeStore;
         private readonly IMessengerSender messengerSender;
         private readonly RelayServerConnectionTransfer relayServerConnectionTransfer;
+        private readonly RelayServerNodeReportTransfer relayServerNodeReportTransfer;
 
-        public RelayServerNodeTransfer(ISerializer serializer, IRelayServerNodeStore relayServerNodeStore, IMessengerSender messengerSender, RelayServerConnectionTransfer relayServerConnectionTransfer)
+        public RelayServerNodeTransfer(ISerializer serializer, IRelayServerConfigStore relayServerNodeStore, IMessengerSender messengerSender,
+            RelayServerConnectionTransfer relayServerConnectionTransfer, RelayServerNodeReportTransfer relayServerNodeReportTransfer)
         {
             this.serializer = serializer;
             this.relayServerNodeStore = relayServerNodeStore;
             this.messengerSender = messengerSender;
             this.relayServerConnectionTransfer = relayServerConnectionTransfer;
+            this.relayServerNodeReportTransfer = relayServerNodeReportTransfer;
 
             limitTotal.SetLimit((uint)Math.Ceiling((Node.Bandwidth * 1024 * 1024) / 8.0));
-
             TrafficTask();
         }
 
@@ -55,7 +51,7 @@ namespace linker.messenger.relay.server
                 MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
                 {
                     Connection = connection,
-                    MessengerId = (ushort)RelayMessengerIds.NodeGetCache,
+                    MessengerId = (ushort)RelayMessengerIds.GetCache,
                     Payload = serializer.Serialize(new ValueTuple<string, string>(key, Node.NodeId)),
                     Timeout = 1000
                 }).ConfigureAwait(false);
@@ -75,7 +71,7 @@ namespace linker.messenger.relay.server
 
         public bool Validate(TunnelProtocolType tunnelProtocolType)
         {
-            return true;
+            return (Node.Protocol & tunnelProtocolType) == tunnelProtocolType;
         }
         /// <summary>
         /// 无效请求
@@ -91,9 +87,9 @@ namespace linker.messenger.relay.server
         /// <returns></returns>
         private bool ValidateConnection(RelayCacheInfo relayCache)
         {
-            bool res = Node.Connections == 0 || Node.Connections * 2 > connectionNum;
+            bool res = Node.Connections == 0 || Node.Connections * 2 > relayServerNodeReportTransfer.ConnectionNum;
             if (res == false && LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                LoggerHelper.Instance.Debug($"relay  ValidateConnection false,{connectionNum}/{Node.Connections * 2}");
+                LoggerHelper.Instance.Debug($"relay  validate connection false,{relayServerNodeReportTransfer.ConnectionNum}/{Node.Connections * 2}");
 
             return res;
         }
@@ -117,14 +113,14 @@ namespace linker.messenger.relay.server
         /// </summary>
         public void IncrementConnectionNum()
         {
-            Interlocked.Increment(ref connectionNum);
+            relayServerNodeReportTransfer.IncrementConnectionNum();
         }
         /// <summary>
         /// 减少连接数
         /// </summary>
         public void DecrementConnectionNum()
         {
-            Interlocked.Decrement(ref connectionNum);
+            relayServerNodeReportTransfer.DecrementConnectionNum();
         }
 
         /// <summary>
@@ -179,7 +175,7 @@ namespace linker.messenger.relay.server
         /// <returns></returns>
         public bool AddBytes(RelayTrafficCacheInfo cache, long length)
         {
-            Interlocked.Add(ref bytes, length);
+            relayServerNodeReportTransfer.AddBytes(length);
 
             if (Node.DataEachMonth == 0) return true;
 
@@ -213,13 +209,13 @@ namespace linker.messenger.relay.server
                 long length = Interlocked.Exchange(ref cache.Sendt, 0);
 
                 if (Node.DataRemain >= length)
-                    relayServerNodeStore.SetMaxGbTotalLastBytes(Node.DataRemain - length);
-                else relayServerNodeStore.SetMaxGbTotalLastBytes(0);
+                    relayServerNodeStore.SetDataRemain(Node.DataRemain - length);
+                else relayServerNodeStore.SetDataRemain(0);
             }
             if (Node.DataMonth != DateTime.Now.Month)
             {
-                relayServerNodeStore.SetMaxGbTotalMonth(DateTime.Now.Month);
-                relayServerNodeStore.SetMaxGbTotalLastBytes((long)(Node.DataEachMonth * 1024 * 1024 * 1024));
+                relayServerNodeStore.DataMonth(DateTime.Now.Month);
+                relayServerNodeStore.SetDataRemain((long)(Node.DataEachMonth * 1024 * 1024 * 1024));
             }
             relayServerNodeStore.Confirm();
         }
diff --git a/src/linker.messenger.relay/server/validator/IRelayServerValidator.cs b/src/linker.messenger.relay/server/validator/IRelayServerValidator.cs
index 54801822..f1958b5b 100644
--- a/src/linker.messenger.relay/server/validator/IRelayServerValidator.cs
+++ b/src/linker.messenger.relay/server/validator/IRelayServerValidator.cs
@@ -23,6 +23,6 @@ namespace linker.messenger.relay.server.validator
         /// <param name="fromMachine"></param>
         /// <param name="nodes"></param>
         /// <returns></returns>
-        public Task<List<RelayNodeStoreInfo>> Validate(string userid, SignCacheInfo from, List<RelayNodeStoreInfo> nodes);
+        public Task<List<RelayServerNodeStoreInfo>> Validate(string userid, SignCacheInfo from, List<RelayServerNodeStoreInfo> nodes);
     }
 }
diff --git a/src/linker.messenger.relay/server/validator/RelayServerValidatorTransfer.cs b/src/linker.messenger.relay/server/validator/RelayServerValidatorTransfer.cs
index 474bb374..cee412c6 100644
--- a/src/linker.messenger.relay/server/validator/RelayServerValidatorTransfer.cs
+++ b/src/linker.messenger.relay/server/validator/RelayServerValidatorTransfer.cs
@@ -59,7 +59,7 @@ namespace linker.messenger.relay.server.validator
             }
             return string.Empty;
         }
-        public async Task<List<RelayNodeStoreInfo>> Validate(string userid, SignCacheInfo fromMachine, List<RelayNodeStoreInfo> nodes)
+        public async Task<List<RelayServerNodeStoreInfo>> Validate(string userid, SignCacheInfo fromMachine, List<RelayServerNodeStoreInfo> nodes)
         {
             foreach (var item in validators)
             {
diff --git a/src/linker.messenger.relay/transport/TransportRelay.cs b/src/linker.messenger.relay/transport/TransportRelay.cs
index a3a30243..212dadcb 100644
--- a/src/linker.messenger.relay/transport/TransportRelay.cs
+++ b/src/linker.messenger.relay/transport/TransportRelay.cs
@@ -6,7 +6,6 @@ using linker.messenger.relay.server;
 using linker.messenger.signin;
 using linker.tunnel.connection;
 using linker.tunnel.wanport;
-using System;
 using System.Buffers;
 using System.Net;
 using System.Net.Security;
@@ -55,6 +54,12 @@ namespace linker.tunnel.transport
             this.tunnelMessengerAdapter = tunnelMessengerAdapter;
         }
 
+        private X509Certificate certificate;
+        public void SetSSL(X509Certificate certificate)
+        {
+            this.certificate = certificate;
+        }
+
         public virtual async Task<ITunnelConnection> ConnectAsync(TunnelTransportInfo tunnelTransportInfo)
         {
             byte[] buffer = ArrayPool<byte>.Shared.Rent(1024);
@@ -62,25 +67,24 @@ namespace linker.tunnel.transport
             {
                 //问一下能不能中继
                 RelayAskResultInfo ask = await RelayAsk(tunnelTransportInfo).ConfigureAwait(false);
-                List<RelayNodeStoreInfo> nodes = ask.Nodes;
+                List<RelayServerNodeStoreInfo> nodes = ask.Nodes;
                 if (ask.Nodes.Count == 0)
                 {
-                    return null;
+                    throw new Exception("relay ask fail,no relay nodes");
                 }
 
                 //连接中继节点服务器
                 Socket socket = await ConnectNodeServer(tunnelTransportInfo, ask).ConfigureAwait(false);
-                if (socket == null)
+                if(socket == null)
                 {
-                    return null;
+                    throw new Exception("connect relay node server fail");
                 }
-
                 tunnelTransportInfo.TransactionTag = ask.Info.ToJson();
 
                 //让对方确认中继
                 if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
                 {
-                    return null;
+                    throw new Exception("relay begin fail");
                 }
 
                 //成功建立连接，
@@ -98,6 +102,8 @@ namespace linker.tunnel.transport
 #pragma warning restore SYSLIB0039 // 类型或成员已过时
                 }
 
+                await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
+
                 return new TunnelConnectionTcp
                 {
                     Direction = TunnelDirection.Forward,
@@ -127,6 +133,7 @@ namespace linker.tunnel.transport
             {
                 ArrayPool<byte>.Shared.Return(buffer);
             }
+            await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
             return null;
         }
         private async Task<RelayAskResultInfo> RelayAsk(TunnelTransportInfo tunnelTransportInfo)
@@ -149,7 +156,7 @@ namespace linker.tunnel.transport
             }).ConfigureAwait(false);
             if (resp.Code != MessageResponeCodes.OK)
             {
-                return new RelayAskResultInfo { Info = relayInfo, Nodes = new List<RelayNodeStoreInfo>() };
+                return new RelayAskResultInfo { Info = relayInfo, Nodes = new List<RelayServerNodeStoreInfo>() };
             }
             RelayAskResultInfo ask = serializer.Deserialize<RelayAskResultInfo>(resp.Data.Span);
             ask.Info = relayInfo;
@@ -184,7 +191,7 @@ namespace linker.tunnel.transport
                         await socket.ConnectAsync(ep).WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
                         if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                         {
-                            LoggerHelper.Instance.Debug($"relay  connected {ep}");
+                            LoggerHelper.Instance.Debug($"relay connected {ep}");
                         }
 
                         //建立关联
@@ -231,7 +238,6 @@ namespace linker.tunnel.transport
             return true;
         }
 
-
         private async Task<bool> SendMessage(Socket socket, RelayMessageInfo relayMessage)
         {
             try
@@ -256,11 +262,17 @@ namespace linker.tunnel.transport
             return false;
         }
 
-
         public virtual async Task OnBegin(TunnelTransportInfo tunnelTransportInfo)
         {
             try
             {
+                if (tunnelTransportInfo.SSL && certificate == null)
+                {
+                    LoggerHelper.Instance.Error($"{Name}->ssl Certificate not found");
+                    await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
+                    return;
+                }
+
                 RelayInfo relayInfo = tunnelTransportInfo.TransactionTag.DeJson<RelayInfo>();
 
                 IPEndPoint ep = relayInfo.Node == null || relayInfo.Node.Address.Equals(IPAddress.Any) ? signInClientState.Connection.Address : relayInfo.Node;
@@ -281,6 +293,7 @@ namespace linker.tunnel.transport
                     {
                         ITunnelConnection connection = await WaitSSL(socket, tunnelTransportInfo, relayInfo);
                         OnConnected(connection);
+                        await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
                         return;
                     }
                 }
@@ -300,6 +313,7 @@ namespace linker.tunnel.transport
                 }
             }
             OnConnected(null);
+            await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
         }
         private async Task<TunnelConnectionTcp> WaitSSL(Socket socket, TunnelTransportInfo tunnelTransportInfo, RelayInfo relayInfo)
         {
@@ -346,16 +360,11 @@ namespace linker.tunnel.transport
         public virtual void OnFail(TunnelTransportInfo tunnelTransportInfo)
         {
         }
-
         public virtual void OnSuccess(TunnelTransportInfo tunnelTransportInfo)
         {
         }
 
-        public virtual void SetSSL(X509Certificate certificate)
-        {
-        }
-
-        public async Task<List<RelayNodeStoreInfo>> RelayTestAsync()
+        public async Task<List<RelayServerNodeStoreInfo>> RelayTestAsync()
         {
             try
             {
@@ -368,13 +377,13 @@ namespace linker.tunnel.transport
 
                 if (resp.Code == MessageResponeCodes.OK)
                 {
-                    return serializer.Deserialize<List<RelayNodeStoreInfo>>(resp.Data.Span);
+                    return serializer.Deserialize<List<RelayServerNodeStoreInfo>>(resp.Data.Span);
                 }
             }
             catch (Exception)
             {
             }
-            return new List<RelayNodeStoreInfo>();
+            return new List<RelayServerNodeStoreInfo>();
         }
     }
 
@@ -391,7 +400,7 @@ namespace linker.tunnel.transport
     {
         public RelayInfo Info { get; set; }
         public string MasterId { get; set; }
-        public List<RelayNodeStoreInfo> Nodes { get; set; } = new List<RelayNodeStoreInfo>();
+        public List<RelayServerNodeStoreInfo> Nodes { get; set; } = new List<RelayServerNodeStoreInfo>();
     }
     public sealed partial class RelayMessageInfo
     {
diff --git a/src/linker.messenger.serializer.memorypack/RelaySerializer.cs b/src/linker.messenger.serializer.memorypack/RelaySerializer.cs
index ca701f80..03c10afa 100644
--- a/src/linker.messenger.serializer.memorypack/RelaySerializer.cs
+++ b/src/linker.messenger.serializer.memorypack/RelaySerializer.cs
@@ -16,10 +16,10 @@ namespace linker.messenger.serializer.memorypack
         [MemoryPackInclude]
         string MasterId => info.MasterId;
         [MemoryPackInclude]
-        List<RelayNodeStoreInfo> Nodes => info.Nodes;
+        List<RelayServerNodeStoreInfo> Nodes => info.Nodes;
 
         [MemoryPackConstructor]
-        SerializableRelayAskResultInfo(string masterId, List<RelayNodeStoreInfo> nodes)
+        SerializableRelayAskResultInfo(string masterId, List<RelayServerNodeStoreInfo> nodes)
         {
             var info = new RelayAskResultInfo { MasterId = masterId, Nodes = nodes };
             this.info = info;
@@ -55,7 +55,7 @@ namespace linker.messenger.serializer.memorypack
             reader.TryReadObjectHeader(out byte count);
             value.MasterId = reader.ReadValue<string>();
             if (count > 1)
-                value.Nodes = reader.ReadValue<List<RelayNodeStoreInfo>>();
+                value.Nodes = reader.ReadValue<List<RelayServerNodeStoreInfo>>();
         }
     }
 
diff --git a/src/linker.messenger.store.file/Entry.cs b/src/linker.messenger.store.file/Entry.cs
index 1ee73be4..33b6d0a2 100644
--- a/src/linker.messenger.store.file/Entry.cs
+++ b/src/linker.messenger.store.file/Entry.cs
@@ -69,6 +69,7 @@ namespace linker.messenger.store.file
             serviceCollection.AddSingleton<IUpdaterServerStore, UpdaterServerStore>();
 
             serviceCollection.AddSingleton<IRelayClientStore, RelayClientStore>();
+            serviceCollection.AddSingleton<IRelayServerConfigStore, RelayServerConfigStore>();
             serviceCollection.AddSingleton<IRelayServerNodeStore, RelayServerNodeStore>();
 
             serviceCollection.AddSingleton<ITunnelClientStore, TunnelClientStore>();
diff --git a/src/linker.messenger.store.file/relay/Config.cs b/src/linker.messenger.store.file/relay/Config.cs
index 8c311558..ec711b44 100644
--- a/src/linker.messenger.store.file/relay/Config.cs
+++ b/src/linker.messenger.store.file/relay/Config.cs
@@ -9,7 +9,6 @@ namespace linker.messenger.store.file
         public RelayInfo Relay { get; set; } = new RelayInfo();
 
     }
-
     public sealed class RelayInfo
     {
         public string DefaultNodeId { get; set; } = string.Empty;
@@ -18,19 +17,7 @@ namespace linker.messenger.store.file
 
     public partial class ConfigServerInfo
     {
-        /// <summary>
-        /// 中继配置
-        /// </summary>
-        public RelayConfigServerInfo Relay { get; set; } = new RelayConfigServerInfo();
-    }
-    public sealed class RelayConfigServerInfo
-    {
-        public DistributedInfo Distributed { get; set; } = new DistributedInfo { };
-    }
-
-    public sealed class DistributedInfo
-    {
-        public RelayServerNodeInfo Node { get; set; } = new RelayServerNodeInfo { };
+        public RelayServerConfigInfo Relay { get; set; } = new RelayServerConfigInfo();
     }
 
 }
diff --git a/src/linker.messenger.store.file/relay/RelayServerConfigStore.cs b/src/linker.messenger.store.file/relay/RelayServerConfigStore.cs
new file mode 100644
index 00000000..883e5dbb
--- /dev/null
+++ b/src/linker.messenger.store.file/relay/RelayServerConfigStore.cs
@@ -0,0 +1,34 @@
+using linker.messenger.relay.server;
+
+namespace linker.messenger.store.file.relay
+{
+    public sealed class RelayServerConfigStore : IRelayServerConfigStore
+    {
+        public RelayServerConfigInfo Config => config.Data.Server.Relay;
+
+        private readonly FileConfig config;
+        public RelayServerConfigStore(FileConfig config)
+        {
+            this.config = config;
+        }
+
+        public void Confirm()
+        {
+            config.Data.Update();
+        }
+
+        public void SetInfo(RelayServerConfigInfo node)
+        {
+            config.Data.Server.Relay = node;
+        }
+        public void SetDataRemain(long value)
+        {
+            config.Data.Server.Relay.DataRemain = value;
+        }
+
+        public void DataMonth(int month)
+        {
+            config.Data.Server.Relay.DataMonth = month;
+        }
+    }
+}
diff --git a/src/linker.messenger.store.file/relay/RelayServerNodeStore.cs b/src/linker.messenger.store.file/relay/RelayServerNodeStore.cs
index f016dad6..d69f8341 100644
--- a/src/linker.messenger.store.file/relay/RelayServerNodeStore.cs
+++ b/src/linker.messenger.store.file/relay/RelayServerNodeStore.cs
@@ -1,37 +1,35 @@
 using linker.messenger.relay.server;
+using LiteDB;
 
 namespace linker.messenger.store.file.relay
 {
     public sealed class RelayServerNodeStore : IRelayServerNodeStore
     {
-        public int ServicePort => config.Data.Server.ServicePort;
-        public RelayServerNodeInfo Node => config.Data.Server.Relay.Distributed.Node;
+        private readonly ILiteCollection<RelayServerNodeStoreInfo> liteCollection;
 
-        private readonly FileConfig config;
-        public RelayServerNodeStore(FileConfig config)
+        public RelayServerNodeStore(Storefactory storefactory)
         {
-            this.config = config;
+            liteCollection  = storefactory.GetCollection<RelayServerNodeStoreInfo>("relay_server_master");
         }
 
-        public void Confirm()
+        public async Task<bool> Add(RelayServerNodeStoreInfo info)
         {
-            config.Data.Update();
+            if(liteCollection.FindOne(c=>c.NodeId == info.NodeId) != null)
+            {
+                return false;
+            }
+            liteCollection.Insert(info);
+            return await Task.FromResult(true).ConfigureAwait(false);
         }
 
-        public void SetInfo(RelayServerNodeInfo node)
+        public async Task<List<RelayServerNodeStoreInfo>> GetAll()
         {
-            config.Data.Server.Relay.Distributed.Node = node;
-        }
-        public void SetMaxGbTotalLastBytes(long value)
-        {
-            config.Data.Server.Relay.Distributed.Node.DataRemain = value;
+            return await Task.FromResult(liteCollection.FindAll().ToList()).ConfigureAwait(false);
         }
 
-        public void SetMaxGbTotalMonth(int month)
+        public async Task<RelayServerNodeStoreInfo> GetByNodeId(string nodeId)
         {
-            config.Data.Server.Relay.Distributed.Node.DataMonth = month;
+            return await Task.FromResult(liteCollection.FindOne(c => c.NodeId == nodeId)).ConfigureAwait(false);
         }
-
-
     }
 }