networkMask := uint32(0x5f67705f)
msgSizeBytes := uint64(8 << 10)
netMsgSettings := net_message.NewSettings(&net_message.SSettings{
    FWorkSizeBits: 18,
    FNetworkKey:   "oi4r9NW9Le7fKF9d",
})
node := anonymity.NewNode(
    anonymity.NewSettings(&anonymity.SSettings{
        FNetworkMask:  networkMask,
        FServiceName:  "service",
        FFetchTimeout: time.Minute,
    }),
    logger.NewLogger(
		logger.NewSettings(&logger.SSettings{
            FInfo: os.Stdout,
    		FWarn: os.Stdout,
            FErro: os.Stderr,
        }),
		func(pLogArg logger.ILogArg) string {
    		logFactory, ok := pLogArg.(anon_logger.ILogGetterFactory)
    		if !ok {
    			panic("got invalid log arg")
    		}
    		logGetter := logFactory.Get()
            return encoding.HexEncode(logGetter.GetHash())
    	},
	),
    func() database.IKVDatabase {
        db, err := database.NewKVDatabase(dbPath)
    	if err != nil {
    		panic(err)
    	}
        return db
    }(),
    network.NewNode(
        network.NewSettings(&network.SSettings{
            FAddress:      "localhost:9571",
            FMaxConnects:  256,
            FReadTimeout:  5*time.Second,
            FWriteTimeout: 5*time.Second,
            FConnSettings: conn.NewSettings(&conn.SSettings{
                FMessageSettings: netMsgSettings,
                FLimitMessageSizeBytes: msgSizeBytes,
                FWaitReadTimeout:       time.Hour,
                FDialTimeout:           5*time.Second,
                FReadTimeout:           5*time.Second,
                FWriteTimeout:          5*time.Second,
            }),
        }),
        cache.NewLRUCache(2 << 10),
    ),
    queue.NewQBProblemProcessor(
        queue.NewSettings(&queue.SSettings{
            FMessageConstructSettings: net_message.NewConstructSettings(&net_message.SConstructSettings{
                FSettings: netMsgSettings,
                FParallel: 1,
            }),
            FNetworkMask: networkMask,
            FQueuePeriod: 5*time.Second,
            FPoolCapacity: [2]uint64{256, 32},
        }),
        func() client.IClient {
            client := client.NewClient(asymmetric.NewPrivKey(), msgSizeBytes)
            if client.GetPayloadLimit() <= encoding.CSizeUint64 {
                panic(`client.GetPayloadLimit() <= encoding.CSizeUint64`)
            }
            return client
        }(),
    ),
    asymmetric.NewMapPubKeys(),
).HandleFunc(
    0x5f686c5f,
    func(
		pCtx context.Context,
		pNode anonymity.INode,
		pSender asymmetric.IPubKey,
		pReqBytes []byte,
	) ([]byte, error) {
		loadReq, err := request.LoadRequest(pReqBytes)
		if err != nil {
			return nil, errors.Join(ErrLoadRequest, err)
		}
		service, ok := servicesMap[loadReq.GetHost()]
		if !ok {
			return nil, ErrUndefinedService
		}
		pushReq, err := http.NewRequestWithContext(
			pCtx,
			loadReq.GetMethod(),
			fmt.Sprintf("http://%s%s", service, loadReq.GetPath()),
			bytes.NewReader(loadReq.GetBody()),
		)
		if err != nil {
			return nil, errors.Join(ErrBuildRequest, err)
		}
		for key, val := range loadReq.GetHead() {
			pushReq.Header.Set(key, val)
		}
		pushReq.Header.Set(hls_settings.CHeaderPublicKey, pSender.ToString())
		httpClient := &http.Client{Timeout: time.Minute}
		resp, err := httpClient.Do(pushReq)
		if err != nil {
			logger.PushWarn(logBuilder.WithType(internal_anon_logger.CLogWarnRequestToService))
			return nil, errors.Join(ErrBadRequest, err)
		}
		defer resp.Body.Close()
		respMode := resp.Header.Get(hls_settings.CHeaderResponseMode)
		switch respMode {
		case "", hls_settings.CHeaderResponseModeON:
			return response.NewResponse(resp.StatusCode).
					WithHead(getResponseHead(resp)).
					WithBody(getResponseBody(resp)).
					ToBytes(),
				nil
		case hls_settings.CHeaderResponseModeOFF:
			return nil, nil
		default:
			return nil, ErrInvalidResponseMode
		}
	},
)
connKeeper := connkeeper.NewConnKeeper(
    connkeeper.NewSettings(&connkeeper.SSettings{
        FDuration:    10*time.Second,
        FConnections: func() []string{
          return getConnections()
        },
    }),
    node.GetNetworkNode(),
)
...

node := network.NewHiddenLakeNode(
    const networkKey = "oi4r9NW9Le7fKF9d"
    network.NewSettingsByNetworkKey(networkKey, nil),
    asymmetric.NewPrivKey(),
    func() database.IKVDatabase {
        kv, err := database.NewKVDatabase(dbPath + ".db")
        if err != nil {
            panic(err)
        }
        return kv
    }(),
    func() []string {
        network := hiddenlake.GNetworks[networkKey]
        conns := make([]string, 0, len(network.FConnections))
        for _, c := range network.FConnections {
            conns = append(conns, fmt.Sprintf("%s:%d", c.FHost, c.FPort))
        }
        return conns
    },
    func(_ context.Context, _ asymmetric.IPubKey, r request.IRequest) (response.IResponse, error) {
        rsp := []byte(fmt.Sprintf("echo: %s", string(r.GetBody())))
        return response.NewResponse().WithBody(rsp), nil
    },
)
...

func runNode(ctx context.Context, dbPath string) network.IHiddenLakeNode {
	const networkKey = "oi4r9NW9Le7fKF9d"
  
	node := network.NewHiddenLakeNode(
        // Задаём настройки узла исходя из ключа сети
		network.NewSettingsByNetworkKey(networkKey, nil),
      
        // Приватный ключ - идентификатор узла
		asymmetric.NewPrivKey(),

        // База данных нужна для сохранения хешей принимаемых шифртекстов
		func() database.IKVDatabase {
			kv, err := database.NewKVDatabase(dbPath + ".db")
			if err != nil {
				panic(err)
			}
			return kv
		}(),

        // Подключаем все соединения из build/networks.yml по ключу сети
		func() []string {
			network := hiddenlake.GNetworks[networkKey]
			conns := make([]string, 0, len(network.FConnections))
			for _, c := range network.FConnections {
				conns = append(conns, fmt.Sprintf("%s:%d", c.FHost, c.FPort))
			}
			return conns
		},

        // Пример запуска простого echo-сервиса
		func(_ context.Context, _ asymmetric.IPubKey, r request.IRequest) (response.IResponse, error) {
			rsp := []byte(fmt.Sprintf("echo: %s", string(r.GetBody())))
			return response.NewResponse().WithBody(rsp), nil
		},
	)

    // Запускаем узел на 
    // 1. генерацию шифрованного трафика
    // 2. подключение к ретрансляторам
	go func() { _ = node.Run(ctx) }()
	return node
}

func exchangeKeys(hlNode1, hlNode2 network.IHiddenLakeNode) (asymmetric.IPubKey, asymmetric.IPubKey) {
	node1 := hlNode1.GetOrigNode()
	node2 := hlNode2.GetOrigNode()

	pubKey1 := node1.GetMessageQueue().GetClient().GetPrivKey().GetPubKey()
	pubKey2 := node2.GetMessageQueue().GetClient().GetPrivKey().GetPubKey()

	node1.GetMapPubKeys().SetPubKey(pubKey2)
	node2.GetMapPubKeys().SetPubKey(pubKey1)

	return pubKey1, pubKey2
}