@ozdao/prometheus-framework 0.2.330 → 0.2.332

package/dist/wallet.server.mjs

@@ -1,234 +1,283 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
-import { m as middlewares } from "./index-CW2mOwo8.mjs";
+import { r as requireMiddlewares } from "./index-Ctf6Y61O.mjs";
 import "axios";
 import "bcryptjs";
 import "crypto";
 import require$$2 from "qrcode";
-import { t as tickets_controller } from "./tickets.controller-D4HKBmCa.mjs";
+import { r as requireTickets_controller } from "./tickets.controller-YKLaYwKj.mjs";
 import require$$0 from "stripe";
 import require$$0$1 from "mongoose";
 import require$$1 from "bignumber.js";
-import "./queryProcessor-CyQch65j.mjs";
-var wallet_model = (db) => {
-  const WalletSchema = new db.mongoose.Schema(
-    {
-      owner: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: () => {
-          if ((void 0).owner.type === "user") return "User";
-          if ((void 0).owner.type === "organization") return "Organization";
+import { r as requireQueryProcessor } from "./queryProcessor-C_l-zkrM.mjs";
+var wallet_model;
+var hasRequiredWallet_model;
+function requireWallet_model() {
+  if (hasRequiredWallet_model) return wallet_model;
+  hasRequiredWallet_model = 1;
+  wallet_model = (db) => {
+    const WalletSchema = new db.mongoose.Schema(
+      {
+        owner: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: () => {
+            if (this.owner.type === "user") return "User";
+            if (this.owner.type === "organization") return "Organization";
+          },
+          required: true
         },
-        required: true
+        balances: [{
+          name: String,
+          // Name of currency
+          amount: Number,
+          // Amount
+          locked_amount: Number
+        }]
       },
-      balances: [{
-        name: String,
-        // Name of currency
-        amount: Number,
-        // Amount
-        locked_amount: Number
-      }]
-    },
-    {
-      timestamps: {
-        currentTime: () => Date.now()
-      }
-    },
-    { strict: false }
-  );
-  return db.mongoose.model("Wallet", WalletSchema);
-};
-var payment_model = (db) => {
-  const PaymentSchema = new db.mongoose.Schema({
-    data: {
-      type: Object
-    },
-    currency: {
-      type: String
-    },
-    status: {
-      type: String
-    },
-    customer: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "User"
-    },
-    creator: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "User"
-    }
-  }, {
-    timestamps: {
-      currentTime: () => Date.now()
-    }
-  });
-  const Payment = db.mongoose.model("Payment", PaymentSchema);
-  return Payment;
-};
-var reward_model = (db) => {
-  const RewardSchema = new db.mongoose.Schema(
-    {
-      user: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: () => {
-          if ((void 0).owner.type === "user") return "User";
-          if ((void 0).owner.type === "organization") return "Organization";
-        },
-        required: true
+      {
+        timestamps: {
+          currentTime: () => Date.now()
+        }
+      },
+      { strict: false }
+    );
+    return db.mongoose.model("Wallet", WalletSchema);
+  };
+  return wallet_model;
+}
+var payment_model;
+var hasRequiredPayment_model;
+function requirePayment_model() {
+  if (hasRequiredPayment_model) return payment_model;
+  hasRequiredPayment_model = 1;
+  payment_model = (db) => {
+    const PaymentSchema = new db.mongoose.Schema({
+      data: {
+        type: Object
       },
-      type: {
-        type: String,
-        enum: ["blogpost", "order"],
-        required: true
+      currency: {
+        type: String
       },
-      target: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: () => {
-          if ((void 0).owner.blogpost === "blogpost") return "Blogpost";
-          if ((void 0).owner.blogpost === "order") return "Order";
-        },
-        required: true
+      status: {
+        type: String
       },
-      amount: {
-        type: String,
-        required: true
+      customer: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
       },
-      snapshot: {
-        views: {
-          type: String,
+      creator: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      }
+    }, {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
+    });
+    const Payment = db.mongoose.model("Payment", PaymentSchema);
+    return Payment;
+  };
+  return payment_model;
+}
+var reward_model;
+var hasRequiredReward_model;
+function requireReward_model() {
+  if (hasRequiredReward_model) return reward_model;
+  hasRequiredReward_model = 1;
+  reward_model = (db) => {
+    const RewardSchema = new db.mongoose.Schema(
+      {
+        user: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: () => {
+            if (this.owner.type === "user") return "User";
+            if (this.owner.type === "organization") return "Organization";
+          },
           required: true
         },
-        reactions: {
+        type: {
           type: String,
+          enum: ["blogpost", "order"],
+          required: true
+        },
+        target: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: () => {
+            if (this.owner.blogpost === "blogpost") return "Blogpost";
+            if (this.owner.blogpost === "order") return "Order";
+          },
           required: true
         },
-        comments: {
+        amount: {
           type: String,
           required: true
+        },
+        snapshot: {
+          views: {
+            type: String,
+            required: true
+          },
+          reactions: {
+            type: String,
+            required: true
+          },
+          comments: {
+            type: String,
+            required: true
+          }
         }
+      },
+      {
+        timestamps: {
+          currentTime: () => Date.now()
+        }
+      },
+      { strict: false }
+    );
+    return db.mongoose.model("Reward", RewardSchema);
+  };
+  return reward_model;
+}
+var payments_factory;
+var hasRequiredPayments_factory;
+function requirePayments_factory() {
+  if (hasRequiredPayments_factory) return payments_factory;
+  hasRequiredPayments_factory = 1;
+  const QRCode = require$$2;
+  const controllerFactory = (db) => {
+    const Payment = db.payment;
+    const Wallet = db.wallet;
+    db.order;
+    const create = async (req, res) => {
+      let { amount, positions, userId } = req.body;
+      const newPayment = new Payment(req.body);
+      await newPayment.save();
+      const qrData = `PaymentID:${newPayment._id};Amount:${amount}`;
+      const qrCode = await QRCode.toDataURL(qrData);
+      res.send({ qrCode, paymentId: newPayment._id });
+    };
+    const read = async (req, res) => {
+      try {
+        const paymentes = await Payment.find({}).sort({ "createdAt": "desc" }).exec();
+        if (!paymentes) {
+          return res.status(404).send({ message: "Paymentes not found." });
+        }
+        res.status(200).send(paymentes);
+      } catch (err) {
+        res.status(500).send({ message: err.toString() });
       }
-    },
-    {
-      timestamps: {
-        currentTime: () => Date.now()
+    };
+    const update = async (req, res) => {
+      const session = await db.mongoose.startSession();
+      session.startTransaction();
+      try {
+        const { paymentId, walletId } = req.body;
+        const payment = await Payment.findById(paymentId).session(session);
+        if (!payment) {
+          throw new Error("Payment not found");
+        }
+        if (payment.status !== "pending") {
+          throw new Error("Payment is not in a pending state");
+        }
+        const wallet = await Wallet.findById(walletId).session(session);
+        if (!wallet) {
+          throw new Error("Wallet not found");
+        }
+        if (wallet.amount < payment.amount) {
+          throw new Error("Insufficient funds");
+        }
+        wallet.amount -= payment.amount;
+        await wallet.save({ session });
+        payment.status = "completed";
+        await payment.save({ session });
+        await session.commitTransaction();
+        res.send("Payment processed successfully");
+      } catch (error) {
+        await session.abortTransaction();
+        res.status(500).send(error.message);
+      } finally {
+        session.endSession();
       }
-    },
-    { strict: false }
-  );
-  return db.mongoose.model("Reward", RewardSchema);
-};
-const QRCode = require$$2;
-const controllerFactory$1 = (db) => {
-  const Payment = db.payment;
-  const Wallet = db.wallet;
-  db.order;
-  const create = async (req, res) => {
-    let { amount, positions, userId } = req.body;
-    const newPayment = new Payment(req.body);
-    await newPayment.save();
-    const qrData = `PaymentID:${newPayment._id};Amount:${amount}`;
-    const qrCode = await QRCode.toDataURL(qrData);
-    res.send({ qrCode, paymentId: newPayment._id });
+    };
+    const deletePayment = (req, res) => {
+      Payment.findOneAndDelete({ _id: req.params._id }, (err, payment) => {
+        if (err) {
+          return res.status(500).send({ message: err });
+        }
+        if (!payment) {
+          return res.status(404).send({ message: "Something wrong when deleting payment." });
+        }
+        res.status(200).send(payment);
+      });
+    };
+    return {
+      create,
+      read,
+      update,
+      delete: deletePayment
+    };
   };
-  const read = async (req, res) => {
-    try {
-      const paymentes = await Payment.find({}).sort({ "createdAt": "desc" }).exec();
-      if (!paymentes) {
-        return res.status(404).send({ message: "Paymentes not found." });
-      }
-      res.status(200).send(paymentes);
-    } catch (err) {
-      res.status(500).send({ message: err.toString() });
+  payments_factory = controllerFactory;
+  return payments_factory;
+}
+var globals_webhook;
+var hasRequiredGlobals_webhook;
+function requireGlobals_webhook() {
+  if (hasRequiredGlobals_webhook) return globals_webhook;
+  hasRequiredGlobals_webhook = 1;
+  class Webhook {
+    constructor(app, db, observer, path, handlerMethod, middlewares = []) {
+      this.app = app;
+      this.db = db;
+      this.observer = observer;
+      this.app.post(path, [...middlewares, handlerMethod.bind(this)]);
     }
-  };
-  const update = async (req, res) => {
-    const session = await db.mongoose.startSession();
-    session.startTransaction();
-    try {
-      const { paymentId, walletId } = req.body;
-      const payment = await Payment.findById(paymentId).session(session);
-      if (!payment) {
-        throw new Error("Payment not found");
-      }
-      if (payment.status !== "pending") {
-        throw new Error("Payment is not in a pending state");
-      }
-      const wallet = await Wallet.findById(walletId).session(session);
-      if (!wallet) {
-        throw new Error("Wallet not found");
-      }
-      if (wallet.amount < payment.amount) {
-        throw new Error("Insufficient funds");
-      }
-      wallet.amount -= payment.amount;
-      await wallet.save({ session });
-      payment.status = "completed";
-      await payment.save({ session });
-      await session.commitTransaction();
-      res.send("Payment processed successfully");
-    } catch (error) {
-      await session.abortTransaction();
-      res.status(500).send(error.message);
-    } finally {
-      session.endSession();
+    // Abstract method, must be implemented in derived classes
+    handleWebhook(req, res) {
+      throw new Error("handleWebhook() must be implemented by subclasses");
     }
-  };
-  const deletePayment = (req, res) => {
-    Payment.findOneAndDelete({ _id: req.params._id }, (err, payment) => {
-      if (err) {
-        return res.status(500).send({ message: err });
-      }
-      if (!payment) {
-        return res.status(404).send({ message: "Something wrong when deleting payment." });
-      }
-      res.status(200).send(payment);
-    });
-  };
-  return {
-    create,
-    read,
-    update,
-    delete: deletePayment
-  };
-};
-var payments_factory = controllerFactory$1;
-let Webhook$1 = class Webhook {
-  constructor(app, db, observer, path, handlerMethod, middlewares2 = []) {
-    this.app = app;
-    this.db = db;
-    this.observer = observer;
-    this.app.post(path, [...middlewares2, handlerMethod.bind(this)]);
-  }
-  // Abstract method, must be implemented in derived classes
-  handleWebhook(req, res) {
-    throw new Error("handleWebhook() must be implemented by subclasses");
   }
-};
-var globals_webhook = Webhook$1;
-let Observer$1 = class Observer {
-  constructor() {
-    this.listeners = {};
-  }
-  subscribe(eventType, callback, once = false) {
-    if (!this.listeners[eventType]) {
-      this.listeners[eventType] = /* @__PURE__ */ new Map();
+  globals_webhook = Webhook;
+  return globals_webhook;
+}
+var globals_observer;
+var hasRequiredGlobals_observer;
+function requireGlobals_observer() {
+  if (hasRequiredGlobals_observer) return globals_observer;
+  hasRequiredGlobals_observer = 1;
+  class Observer {
+    constructor() {
+      this.listeners = {};
     }
-    this.listeners[eventType].set(callback, { once });
-  }
-  async notify(eventType, data) {
-    if (this.listeners[eventType]) {
-      const promises = [];
-      const callbacksToRemove = [];
-      for (const [callback, { once }] of this.listeners[eventType]) {
-        const promise = Promise.resolve().then(() => callback(data)).catch((error) => {
-          console.error("Error executing callback:", error);
-        });
-        promises.push(promise);
-        if (once) {
-          callbacksToRemove.push(callback);
+    subscribe(eventType, callback, once = false) {
+      if (!this.listeners[eventType]) {
+        this.listeners[eventType] = /* @__PURE__ */ new Map();
+      }
+      this.listeners[eventType].set(callback, { once });
+    }
+    async notify(eventType, data) {
+      if (this.listeners[eventType]) {
+        const promises = [];
+        const callbacksToRemove = [];
+        for (const [callback, { once }] of this.listeners[eventType]) {
+          const promise = Promise.resolve().then(() => callback(data)).catch((error) => {
+            console.error("Error executing callback:", error);
+          });
+          promises.push(promise);
+          if (once) {
+            callbacksToRemove.push(callback);
+          }
+        }
+        await Promise.all(promises);
+        for (const callback of callbacksToRemove) {
+          this.listeners[eventType].delete(callback);
+          if (this.listeners[eventType].size === 0) {
+            delete this.listeners[eventType];
+          }
         }
       }
-      await Promise.all(promises);
-      for (const callback of callbacksToRemove) {
+    }
+    remove(eventType, callback) {
+      if (this.listeners[eventType]?.has(callback)) {
         this.listeners[eventType].delete(callback);
         if (this.listeners[eventType].size === 0) {
           delete this.listeners[eventType];
@@ -236,389 +285,420 @@ let Observer$1 = class Observer {
       }
     }
   }
-  remove(eventType, callback) {
-    if (this.listeners[eventType]?.has(callback)) {
-      this.listeners[eventType].delete(callback);
-      if (this.listeners[eventType].size === 0) {
-        delete this.listeners[eventType];
-      }
-    }
-  }
-};
-var globals_observer = Observer$1;
-const stripe = require$$0(process.env.STRIPE_SECRET_KEY);
-const Webhook2 = globals_webhook;
-function middleware(req, res, next) {
-  next();
+  globals_observer = Observer;
+  return globals_observer;
 }
-class StripeWebhook extends Webhook2 {
-  constructor(app, db, observer, path = "/api/webhook/stripe", handlerMethod = StripeWebhook.prototype.handleWebhook, middlewares2 = []) {
-    super(app, db, observer, path, handlerMethod, [middleware]);
+var stripe_webhook;
+var hasRequiredStripe_webhook;
+function requireStripe_webhook() {
+  if (hasRequiredStripe_webhook) return stripe_webhook;
+  hasRequiredStripe_webhook = 1;
+  const stripe = require$$0(process.env.STRIPE_SECRET_KEY);
+  const Webhook = requireGlobals_webhook();
+  requireGlobals_observer();
+  function middleware(req, res, next) {
+    next();
   }
-  async handleWebhook(req, res) {
-    req.headers["stripe-signature"];
-    try {
-      const payload = req.body;
-      const payloadString = JSON.stringify(payload, null, 2);
-      const secret = process.env.STRIPE_WEBHOOK_SECRET;
-      const header = stripe.webhooks.generateTestHeaderString({
-        payload: payloadString,
-        secret
-      });
-      const event = stripe.webhooks.constructEvent(payloadString, header, secret);
-      this.observer.notify(event.type, event.data.object);
-    } catch (err) {
-      console.log(`Error verifying Stripe webhook signature: ${err.message}`);
-      return res.status(400).send(`Webhook Error: ${err.message}`);
+  class StripeWebhook extends Webhook {
+    constructor(app, db, observer, path = "/api/webhook/stripe", handlerMethod = StripeWebhook.prototype.handleWebhook, middlewares = []) {
+      super(app, db, observer, path, handlerMethod, [middleware]);
+    }
+    async handleWebhook(req, res) {
+      req.headers["stripe-signature"];
+      try {
+        const payload = req.body;
+        const payloadString = JSON.stringify(payload, null, 2);
+        const secret = process.env.STRIPE_WEBHOOK_SECRET;
+        const header = stripe.webhooks.generateTestHeaderString({
+          payload: payloadString,
+          secret
+        });
+        const event = stripe.webhooks.constructEvent(payloadString, header, secret);
+        this.observer.notify(event.type, event.data.object);
+      } catch (err) {
+        console.log(`Error verifying Stripe webhook signature: ${err.message}`);
+        return res.status(400).send(`Webhook Error: ${err.message}`);
+      }
+      res.sendStatus(200);
     }
-    res.sendStatus(200);
   }
+  stripe_webhook = StripeWebhook;
+  return stripe_webhook;
 }
-var stripe_webhook = StripeWebhook;
-const middlewareFactoryAuth$1 = middlewares;
-const controllerFactory = payments_factory;
-const controllerFactoryTickets = tickets_controller;
-const WebhookStripe = stripe_webhook;
-const Observer2 = globals_observer;
-var payments_routes = function(app, db, origins, publicPath) {
-  const observer = new Observer2();
-  new WebhookStripe(app, db, observer);
-  const controller = controllerFactory(db);
-  console.log("payments ticket", publicPath);
-  const controllerTickets = controllerFactoryTickets(db, publicPath);
-  middlewareFactoryAuth$1(db);
-  observer.subscribe("checkout.session.completed", async (paymentIntent) => {
-    try {
-      const event = await db.event.findOne({ _id: paymentIntent.metadata.product });
-      if (!event) {
-        console.error("Event not found:", paymentIntent.metadata.product);
-        return;
-      }
-      const ticketType = event.ticketsTypes.find(
-        (type) => type.name === paymentIntent.metadata.ticketType
-      );
-      if (!ticketType) {
-        console.error("Ticket type not found:", paymentIntent.metadata.ticketType);
-        return;
+var payments_routes;
+var hasRequiredPayments_routes;
+function requirePayments_routes() {
+  if (hasRequiredPayments_routes) return payments_routes;
+  hasRequiredPayments_routes = 1;
+  const middlewareFactoryAuth = requireMiddlewares();
+  const controllerFactory = requirePayments_factory();
+  const controllerFactoryTickets = requireTickets_controller();
+  const WebhookStripe = requireStripe_webhook();
+  const Observer = requireGlobals_observer();
+  payments_routes = function(app, db, origins, publicPath) {
+    const observer = new Observer();
+    new WebhookStripe(app, db, observer);
+    const controller = controllerFactory(db);
+    console.log("payments ticket", publicPath);
+    const controllerTickets = controllerFactoryTickets(db, publicPath);
+    const { verifySignUp, verifyUser } = middlewareFactoryAuth(db);
+    observer.subscribe("checkout.session.completed", async (paymentIntent) => {
+      try {
+        const event = await db.event.findOne({ _id: paymentIntent.metadata.product });
+        if (!event) {
+          console.error("Event not found:", paymentIntent.metadata.product);
+          return;
+        }
+        const ticketType = event.ticketsTypes.find(
+          (type) => type.name === paymentIntent.metadata.ticketType
+        );
+        if (!ticketType) {
+          console.error("Ticket type not found:", paymentIntent.metadata.ticketType);
+          return;
+        }
+        const quantity = paymentIntent.amount_total / (ticketType.price * 100);
+        console.log("Purchase details:");
+        console.log("Email:", paymentIntent.customer_details.email);
+        console.log("Name:", paymentIntent.customer_details.name);
+        console.log("Event ID:", paymentIntent.metadata.eventId);
+        console.log("Ticket Type:", ticketType.name);
+        console.log("Quantity:", quantity);
+        let ticketData = {
+          name: paymentIntent.customer_details.name,
+          email: paymentIntent.customer_details.email,
+          target: paymentIntent.metadata.product,
+          type: "event",
+          seat: ticketType.name,
+          quantity,
+          price: ticketType.price
+        };
+        await controllerTickets.saveAndSendTicket(ticketData);
+      } catch (error) {
+        console.error("Error processing checkout session:", error);
       }
-      const quantity = paymentIntent.amount_total / (ticketType.price * 100);
-      console.log("Purchase details:");
-      console.log("Email:", paymentIntent.customer_details.email);
-      console.log("Name:", paymentIntent.customer_details.name);
-      console.log("Event ID:", paymentIntent.metadata.eventId);
-      console.log("Ticket Type:", ticketType.name);
-      console.log("Quantity:", quantity);
-      let ticketData = {
-        name: paymentIntent.customer_details.name,
-        email: paymentIntent.customer_details.email,
-        target: paymentIntent.metadata.product,
-        type: "event",
-        seat: ticketType.name,
-        quantity,
-        price: ticketType.price
-      };
-      await controllerTickets.saveAndSendTicket(ticketData);
-    } catch (error) {
-      console.error("Error processing checkout session:", error);
-    }
+    });
+    app.get(
+      "/api/payments/read",
+      controller.read
+    );
+    app.post(
+      "/api/payments/create",
+      controller.create
+    );
+    app.post(
+      "/api/payments/update",
+      controller.update
+    );
+    app.delete(
+      "/api/payments/delete",
+      controller.delete
+    );
+  };
+  return payments_routes;
+}
+var rewards_factory;
+var hasRequiredRewards_factory;
+function requireRewards_factory() {
+  if (hasRequiredRewards_factory) return rewards_factory;
+  hasRequiredRewards_factory = 1;
+  const ObjectId = require$$0$1.Types.ObjectId;
+  const { BigNumber } = require$$1;
+  requireQueryProcessor();
+  BigNumber.config({
+    EXPONENTIAL_AT: [-1e3, 2e3]
   });
-  app.get(
-    "/api/payments/read",
-    controller.read
-  );
-  app.post(
-    "/api/payments/create",
-    controller.create
-  );
-  app.post(
-    "/api/payments/update",
-    controller.update
-  );
-  app.delete(
-    "/api/payments/delete",
-    controller.delete
-  );
-};
-const ObjectId = require$$0$1.Types.ObjectId;
-const { BigNumber } = require$$1;
-BigNumber.config({
-  EXPONENTIAL_AT: [-1e3, 2e3]
-});
-const VIEWS_REWARD_COEFF = "0.1";
-const WDT_DECIMALS = 8;
-const calculateRewardForPost = (snapshot, viewsCount, reactionsCount, commentsCount) => {
-  console.log("snapshot", snapshot);
-  if (snapshot) {
-    return new BigNumber(Math.max(viewsCount - snapshot.views, 0)).multipliedBy(VIEWS_REWARD_COEFF).plus(Math.max(reactionsCount - snapshot.reactions, 0)).plus(Math.max(commentsCount - snapshot.comments, 0));
-  }
-  return new BigNumber("10").plus(new BigNumber(viewsCount).multipliedBy(VIEWS_REWARD_COEFF)).plus(reactionsCount).plus(commentsCount);
-};
-const rewardsControllerFactory$1 = (db, wdmClient, wss) => {
-  const Blogpost = db.blogpost;
-  const Reaction = db.reaction;
-  const Comment = db.comment;
-  const Reward = db.reward;
-  const Wallet = db.wallet;
-  const lookup = {};
-  wss.on("connection", (ws, req) => {
-    ws.type = "rewards";
-    if (req.userId) {
-      lookup[req.userId] = ws;
-      ws.on("close", () => {
-        delete lookup[req.userId];
-      });
+  const VIEWS_REWARD_COEFF = "0.1";
+  const WDT_DECIMALS = 8;
+  const calculateRewardForPost = (snapshot, viewsCount, reactionsCount, commentsCount) => {
+    console.log("snapshot", snapshot);
+    if (snapshot) {
+      return new BigNumber(Math.max(viewsCount - snapshot.views, 0)).multipliedBy(VIEWS_REWARD_COEFF).plus(Math.max(reactionsCount - snapshot.reactions, 0)).plus(Math.max(commentsCount - snapshot.comments, 0));
     }
-  });
-  const listRewards = async (req, res) => {
-    const userId = new ObjectId(req.userId);
-    try {
-      const aggregationResults = await Blogpost.aggregate([
-        // Соответствие блогпостов для данного пользователя
-        { $match: { "creator.target": userId } },
-        // Добавление информации о реакциях и комментариях
-        {
-          $lookup: {
-            from: "reactions",
-            localField: "_id",
-            foreignField: "target",
-            as: "reactions"
-          }
-        },
-        {
-          $lookup: {
-            from: "comments",
-            localField: "_id",
-            foreignField: "target",
-            as: "comments"
-          }
-        },
-        // Добавление информации о предыдущей награде
-        {
-          $lookup: {
-            from: "rewards",
-            let: { blogId: "$_id" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $and: [
-                      { $eq: ["$user", userId] },
-                      { $eq: ["$type", "blogpost"] },
-                      { $eq: ["$target", "$$blogId"] }
-                    ]
+    return new BigNumber("10").plus(new BigNumber(viewsCount).multipliedBy(VIEWS_REWARD_COEFF)).plus(reactionsCount).plus(commentsCount);
+  };
+  const rewardsControllerFactory = (db, wdmClient, wss) => {
+    const Blogpost = db.blogpost;
+    const Reaction = db.reaction;
+    const Comment = db.comment;
+    const Reward = db.reward;
+    const Wallet = db.wallet;
+    const lookup = {};
+    wss.on("connection", (ws, req) => {
+      ws.type = "rewards";
+      if (req.userId) {
+        lookup[req.userId] = ws;
+        ws.on("close", () => {
+          delete lookup[req.userId];
+        });
+      }
+    });
+    const listRewards = async (req, res) => {
+      const userId = new ObjectId(req.userId);
+      try {
+        const aggregationResults = await Blogpost.aggregate([
+          // Соответствие блогпостов для данного пользователя
+          { $match: { "creator.target": userId } },
+          // Добавление информации о реакциях и комментариях
+          {
+            $lookup: {
+              from: "reactions",
+              localField: "_id",
+              foreignField: "target",
+              as: "reactions"
+            }
+          },
+          {
+            $lookup: {
+              from: "comments",
+              localField: "_id",
+              foreignField: "target",
+              as: "comments"
+            }
+          },
+          // Добавление информации о предыдущей награде
+          {
+            $lookup: {
+              from: "rewards",
+              let: { blogId: "$_id" },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $and: [
+                        { $eq: ["$user", userId] },
+                        { $eq: ["$type", "blogpost"] },
+                        { $eq: ["$target", "$$blogId"] }
+                      ]
+                    }
                   }
-                }
-              },
-              { $sort: { createdAt: -1 } },
-              { $limit: 1 }
-            ],
-            as: "previousReward"
+                },
+                { $sort: { createdAt: -1 } },
+                { $limit: 1 }
+              ],
+              as: "previousReward"
+            }
+          },
+          // Преобразование результатов
+          {
+            $project: {
+              _id: 1,
+              user: req.userId,
+              type: "blogpost",
+              views: 1,
+              reactionsCount: { $size: "$reactions" },
+              commentsCount: { $size: "$comments" },
+              previousReward: { $arrayElemAt: ["$previousReward", 0] },
+              name: 1,
+              content: 1,
+              url: 1
+            }
           }
-        },
-        // Преобразование результатов
-        {
-          $project: {
-            _id: 1,
+        ]);
+        const rewards = aggregationResults.map((result) => ({
+          user: result.user,
+          type: result.type,
+          amount: calculateRewardForPost(
+            result.previousReward?.snapshot,
+            result.views,
+            result.reactionsCount,
+            result.commentsCount
+          ),
+          name: result.name,
+          content: result.content,
+          url: result.url
+        }));
+        res.status(200).send(rewards);
+      } catch (error) {
+        res.status(500).send({ message: "Произошла ошибка при получении наград", error: error.message });
+      }
+    };
+    const collectTokens = async (req, res) => {
+      const blogs = await Blogpost.find({ "creator.target": req.userId }).exec();
+      let totalRewards = new BigNumber(0);
+      for (const blog of blogs) {
+        const reactions = await Reaction.countDocuments({ target: { $in: blog._id } }).exec();
+        const comments = await Comment.countDocuments({ target: { $in: blog._id } }).exec();
+        const previousReward = await Reward.findOne({ user: req.userId, type: "blogpost", target: blog._id }).sort({ createdAt: -1 }).exec();
+        const reward = calculateRewardForPost(
+          previousReward?.snapshot,
+          blog.views,
+          reactions,
+          comments
+        );
+        if (reward.gt(0)) {
+          totalRewards = totalRewards.plus(reward);
+          const snapshot = {
+            views: previousReward ? previousReward.snapshot.views < blog.views ? blog.views : previousReward.snapshot.views : blog.views,
+            reactions: previousReward ? previousReward.snapshot.reactions < reactions ? reactions : previousReward.snapshot.reactions : reactions,
+            comments: previousReward ? previousReward.snapshot.comments < comments ? comments : previousReward.snapshot.comments : comments
+          };
+          await Reward.create({
             user: req.userId,
             type: "blogpost",
-            views: 1,
-            reactionsCount: { $size: "$reactions" },
-            commentsCount: { $size: "$comments" },
-            previousReward: { $arrayElemAt: ["$previousReward", 0] },
-            name: 1,
-            content: 1,
-            url: 1
-          }
+            target: blog._id,
+            amount: reward.toString(),
+            snapshot
+          });
         }
-      ]);
-      const rewards = aggregationResults.map((result) => ({
-        user: result.user,
-        type: result.type,
-        amount: calculateRewardForPost(
-          result.previousReward?.snapshot,
-          result.views,
-          result.reactionsCount,
-          result.commentsCount
-        ),
-        name: result.name,
-        content: result.content,
-        url: result.url
-      }));
-      res.status(200).send(rewards);
-    } catch (error) {
-      res.status(500).send({ message: "Произошла ошибка при получении наград", error: error.message });
-    }
-  };
-  const collectTokens = async (req, res) => {
-    const blogs = await Blogpost.find({ "creator.target": req.userId }).exec();
-    let totalRewards = new BigNumber(0);
-    for (const blog of blogs) {
-      const reactions = await Reaction.countDocuments({ target: { $in: blog._id } }).exec();
-      const comments = await Comment.countDocuments({ target: { $in: blog._id } }).exec();
-      const previousReward = await Reward.findOne({ user: req.userId, type: "blogpost", target: blog._id }).sort({ createdAt: -1 }).exec();
-      const reward = calculateRewardForPost(
-        previousReward?.snapshot,
-        blog.views,
-        reactions,
-        comments
-      );
-      if (reward.gt(0)) {
-        totalRewards = totalRewards.plus(reward);
-        const snapshot = {
-          views: previousReward ? previousReward.snapshot.views < blog.views ? blog.views : previousReward.snapshot.views : blog.views,
-          reactions: previousReward ? previousReward.snapshot.reactions < reactions ? reactions : previousReward.snapshot.reactions : reactions,
-          comments: previousReward ? previousReward.snapshot.comments < comments ? comments : previousReward.snapshot.comments : comments
-        };
-        await Reward.create({
-          user: req.userId,
-          type: "blogpost",
-          target: blog._id,
-          amount: reward.toString(),
-          snapshot
-        });
       }
-    }
-    if (totalRewards.gt(0)) {
-      await wdmClient.transfer(
-        totalRewards.shiftedBy(WDT_DECIMALS).toString(),
-        req.body.recipient,
+      if (totalRewards.gt(0)) {
+        await wdmClient.transfer(
+          totalRewards.shiftedBy(WDT_DECIMALS).toString(),
+          req.body.recipient,
+          req.userId
+        );
+      }
+      res.status(200).send();
+    };
+    const requestDeposit = async (req, res) => {
+      const response = await wdmClient.createDepositRequest(
+        req.body.network,
+        req.body.amount,
+        req.body.token,
         req.userId
       );
-    }
-    res.status(200).send();
-  };
-  const requestDeposit = async (req, res) => {
-    const response = await wdmClient.createDepositRequest(
-      req.body.network,
-      req.body.amount,
-      req.body.token,
-      req.userId
-    );
-    res.status(200).send(response.data);
-  };
-  const cancelDeposit = async (req, res) => {
-    const response = await wdmClient.cancelDeposit(
-      req.body.id,
-      req.userId
-    );
-    res.status(200).send(response.data);
-  };
-  const getDepositConfig = async (req, res) => {
-    const response = await wdmClient.getDepositConfig();
-    res.status(200).send(response.data);
-  };
-  const handleDepositUpdate = async (req, res) => {
-    if (req.body.status === "TRANSFER_STATUS_COMPLETED") {
-      const userWallet = await Wallet.findOne({ owner: new ObjectId(req.body.user) });
-      const amount = new BigNumber(req.body.amount).shiftedBy(-WDT_DECIMALS).dividedBy(process.env.TOKEN_EXCHANGE_RATE).toString();
-      if (userWallet) {
-        const topupIndex = userWallet.balances.findIndex((b) => b.name === "WDT");
-        if (topupIndex < 0) {
-          userWallet.balances.push({ name: "WDT", amount: +amount, locked_amount: 0 });
+      res.status(200).send(response.data);
+    };
+    const cancelDeposit = async (req, res) => {
+      const response = await wdmClient.cancelDeposit(
+        req.body.id,
+        req.userId
+      );
+      res.status(200).send(response.data);
+    };
+    const getDepositConfig = async (req, res) => {
+      const response = await wdmClient.getDepositConfig();
+      res.status(200).send(response.data);
+    };
+    const handleDepositUpdate = async (req, res) => {
+      if (req.body.status === "TRANSFER_STATUS_COMPLETED") {
+        const userWallet = await Wallet.findOne({ owner: new ObjectId(req.body.user) });
+        const amount = new BigNumber(req.body.amount).shiftedBy(-8).dividedBy(process.env.TOKEN_EXCHANGE_RATE).toString();
+        if (userWallet) {
+          const topupIndex = userWallet.balances.findIndex((b) => b.name === "WDT");
+          if (topupIndex < 0) {
+            userWallet.balances.push({ name: "WDT", amount: +amount, locked_amount: 0 });
+          } else {
+            userWallet.balances[topupIndex] = {
+              name: "WDT",
+              amount: userWallet.balances[topupIndex].amount + +amount,
+              locked_amount: userWallet.balances[topupIndex].locked_amount
+            };
+          }
+          await userWallet.save();
         } else {
-          userWallet.balances[topupIndex] = {
-            name: "WDT",
-            amount: userWallet.balances[topupIndex].amount + +amount,
-            locked_amount: userWallet.balances[topupIndex].locked_amount
-          };
+          await Wallet.create({
+            owner: new ObjectId(req.body.user),
+            balances: [{ name: "WDT", amount: +amount, locked_amount: 0 }]
+          });
         }
-        await userWallet.save();
-      } else {
-        await Wallet.create({
-          owner: new ObjectId(req.body.user),
-          balances: [{ name: "WDT", amount: +amount, locked_amount: 0 }]
-        });
       }
-    }
-    if (lookup[req.body.user]) {
-      lookup[req.body.user].send(JSON.stringify(req.body));
-    }
-    res.status(200).send();
+      if (lookup[req.body.user]) {
+        lookup[req.body.user].send(JSON.stringify(req.body));
+      }
+      res.status(200).send();
+    };
+    return {
+      listRewards,
+      collectTokens,
+      requestDeposit,
+      getDepositConfig,
+      cancelDeposit,
+      handleDepositUpdate
+    };
   };
-  return {
-    listRewards,
-    collectTokens,
-    requestDeposit,
-    getDepositConfig,
-    cancelDeposit,
-    handleDepositUpdate
+  rewards_factory = rewardsControllerFactory;
+  return rewards_factory;
+}
+var rewards_routes;
+var hasRequiredRewards_routes;
+function requireRewards_routes() {
+  if (hasRequiredRewards_routes) return rewards_routes;
+  hasRequiredRewards_routes = 1;
+  const rewardsControllerFactory = requireRewards_factory();
+  const middlewareFactoryAuth = requireMiddlewares();
+  rewards_routes = (app, db, wss, wdmClient, origins) => {
+    const controller = rewardsControllerFactory(db, wdmClient, wss);
+    const { authJwt, authSecret } = middlewareFactoryAuth(db);
+    app.use((req, res, next) => {
+      const origin = req.headers.origin;
+      if (origins.includes(origin)) {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+      }
+      res.header("Access-Control-Allow-Headers", "x-access-token, Origin, Content-Type, Accept");
+      next();
+    });
+    app.get(
+      "/api/crypto/rewards",
+      [authJwt.verifyToken],
+      controller.listRewards
+    );
+    app.post(
+      "/api/crypto/collect",
+      [authJwt.verifyToken],
+      controller.collectTokens
+    );
+    app.post(
+      "/api/crypto/deposit",
+      [authJwt.verifyToken],
+      controller.requestDeposit
+    );
+    app.post(
+      "/api/crypto/deposit/cancel",
+      [authJwt.verifyToken],
+      controller.cancelDeposit
+    );
+    app.post(
+      "/api/crypto/deposit/update",
+      [authSecret.verifySecret("POST", "/api/crypto/deposit/update", process.env.WDM_SECRET)],
+      controller.handleDepositUpdate
+    );
+    app.get(
+      "/api/crypto/deposit/config",
+      [],
+      controller.getDepositConfig
+    );
   };
-};
-var rewards_factory = rewardsControllerFactory$1;
-const rewardsControllerFactory = rewards_factory;
-const middlewareFactoryAuth = middlewares;
-var rewards_routes = (app, db, wss, wdmClient, origins) => {
-  const controller = rewardsControllerFactory(db, wdmClient, wss);
-  const { authJwt, authSecret } = middlewareFactoryAuth(db);
-  app.use((req, res, next) => {
-    const origin = req.headers.origin;
-    if (origins.includes(origin)) {
-      res.setHeader("Access-Control-Allow-Origin", origin);
+  return rewards_routes;
+}
+var wallet_server$1;
+var hasRequiredWallet_server;
+function requireWallet_server() {
+  if (hasRequiredWallet_server) return wallet_server$1;
+  hasRequiredWallet_server = 1;
+  const ModelWallet = requireWallet_model();
+  const ModelPayment = requirePayment_model();
+  const ModelReward = requireReward_model();
+  const RoutesPayments = requirePayments_routes();
+  const RoutesRewards = requireRewards_routes();
+  const FactoryPayments = requirePayments_factory();
+  function initializePayments(app, db, wss, wdmClient, origins, publicPath) {
+    db.wallet = ModelWallet(db);
+    db.payment = ModelPayment(db);
+    db.reward = ModelReward(db);
+    if (app) {
+      RoutesPayments(app, db, origins, publicPath);
     }
-    res.header("Access-Control-Allow-Headers", "x-access-token, Origin, Content-Type, Accept");
-    next();
-  });
-  app.get(
-    "/api/crypto/rewards",
-    [authJwt.verifyToken],
-    controller.listRewards
-  );
-  app.post(
-    "/api/crypto/collect",
-    [authJwt.verifyToken],
-    controller.collectTokens
-  );
-  app.post(
-    "/api/crypto/deposit",
-    [authJwt.verifyToken],
-    controller.requestDeposit
-  );
-  app.post(
-    "/api/crypto/deposit/cancel",
-    [authJwt.verifyToken],
-    controller.cancelDeposit
-  );
-  app.post(
-    "/api/crypto/deposit/update",
-    [authSecret.verifySecret("POST", "/api/crypto/deposit/update", process.env.WDM_SECRET)],
-    controller.handleDepositUpdate
-  );
-  app.get(
-    "/api/crypto/deposit/config",
-    [],
-    controller.getDepositConfig
-  );
-};
-const ModelWallet = wallet_model;
-const ModelPayment = payment_model;
-const ModelReward = reward_model;
-const RoutesPayments = payments_routes;
-const RoutesRewards = rewards_routes;
-const FactoryPayments = payments_factory;
-function initializePayments(app, db, wss, wdmClient, origins, publicPath) {
-  db.wallet = ModelWallet(db);
-  db.payment = ModelPayment(db);
-  db.reward = ModelReward(db);
-  if (app) {
-    RoutesPayments(app, db, origins, publicPath);
   }
+  wallet_server$1 = {
+    initialize: initializePayments,
+    models: {
+      ModelWallet,
+      ModelPayment,
+      ModelReward
+    },
+    routes: {
+      RoutesPayments,
+      RoutesRewards
+    },
+    controllers: {
+      FactoryPayments
+    }
+  };
+  return wallet_server$1;
 }
-var wallet_server = {
-  initialize: initializePayments,
-  models: {
-    ModelWallet,
-    ModelPayment,
-    ModelReward
-  },
-  routes: {
-    RoutesPayments,
-    RoutesRewards
-  },
-  controllers: {
-    FactoryPayments
-  }
-};
-const wallet_server$1 = /* @__PURE__ */ getDefaultExportFromCjs(wallet_server);
+var wallet_serverExports = requireWallet_server();
+const wallet_server = /* @__PURE__ */ getDefaultExportFromCjs(wallet_serverExports);
 export {
-  wallet_server$1 as default
+  wallet_server as default
 };