@ozdao/martyrs 0.2.477 → 0.2.479

package/dist/wallet.server.js

@@ -1,57 +1,372 @@
-"use strict";
-const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
-const index = require("./index-BOmxJQ5W.js");
-require("axios");
-require("bcryptjs");
-require("crypto");
-const require$$2 = require("qrcode");
-const tickets_controller = require("./tickets.controller-zEHIAe_B.js");
-const require$$0 = require("stripe");
-const require$$0$1 = require("mongoose");
-const require$$1 = require("bignumber.js");
-const queryProcessor = require("./queryProcessor-DSUqSk3I.js");
-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
+import * as QRCode from "qrcode";
+import { m as middlewareIndexFactory } from "./index-CsJwdsBW.js";
+import { c as controllerFactory$1 } from "./tickets.controller-DQQcjyui.js";
+import { O as Observer } from "./globals.observer-CDqUjVU5.js";
+import Stripe from "stripe";
+import { BigNumber } from "bignumber.js";
+import { Types } from "mongoose";
+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() });
+    }
+  };
+  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();
+    }
+  };
+  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
+  };
+};
+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)]);
+  }
+  // Abstract method, must be implemented in derived classes
+  handleWebhook(req, res) {
+    throw new Error("handleWebhook() must be implemented by subclasses");
+  }
+}
+const stripe = new Stripe(process.env.STRIPE_API_KEY ?? "", {
+  apiVersion: "2025-04-30.basil"
+});
+function middleware(req, res, next) {
+  next();
+}
+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);
+  }
+}
+const RoutesPayments = function(app, db, origins, publicPath) {
+  const observer = new Observer();
+  new StripeWebhook(app, db, observer);
+  const controller = controllerFactory(db);
+  console.log("payments ticket", publicPath);
+  const controllerTickets = controllerFactory$1(db, publicPath);
+  middlewareIndexFactory(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);
+    }
+  });
+  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 = { Types }.Types.ObjectId;
+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 = (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"
+          }
         },
-        balances: [{
-          name: String,
-          // Name of currency
-          amount: Number,
-          // Amount
-          locked_amount: Number
-        }]
-      },
-      {
-        timestamps: {
-          currentTime: () => Date.now()
+        {
+          $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"
+          }
+        },
+        // Преобразование результатов
+        {
+          $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
+          }
         }
-      },
-      { strict: false }
-    );
-    return db.mongoose.model("Wallet", WalletSchema);
+      ]);
+      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 });
+    }
   };
-  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({
+  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, 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(-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 {
+        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();
+  };
+  return {
+    listRewards,
+    collectTokens,
+    requestDeposit,
+    getDepositConfig,
+    cancelDeposit,
+    handleDepositUpdate
+  };
+};
+const RoutesRewards = (app, db, wss, wdmClient, origins) => {
+  const controller = rewardsControllerFactory(db, wdmClient, wss);
+  const { authJwt, authSecret } = middlewareIndexFactory(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);
+};
+const ModelPayment = (db) => {
+  const PaymentSchema = new db.mongoose.Schema(
+    {
       data: {
         type: Object
       },
@@ -69,636 +384,128 @@ function requirePayment_model() {
         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
+    }
+  );
+  const Payment = db.mongoose.model("Payment", PaymentSchema);
+  return Payment;
+};
+const ModelReward = (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
+      },
+      type: {
+        type: String,
+        enum: ["blogpost", "order"],
+        required: true
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: () => {
+          if ((void 0).owner.blogpost === "blogpost") return "Blogpost";
+          if ((void 0).owner.blogpost === "order") return "Order";
         },
-        type: {
+        required: true
+      },
+      amount: {
+        type: String,
+        required: true
+      },
+      snapshot: {
+        views: {
           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";
-          },
+        reactions: {
+          type: String,
           required: true
         },
-        amount: {
+        comments: {
           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() });
-      }
-    };
-    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();
-      }
-    };
-    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
-    };
-  };
-  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)]);
-    }
-    // Abstract method, must be implemented in derived classes
-    handleWebhook(req, res) {
-      throw new Error("handleWebhook() must be implemented by subclasses");
-    }
-  }
-  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 = {};
-    }
-    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];
-          }
-        }
-      }
-    }
-    remove(eventType, callback) {
-      if (this.listeners[eventType]?.has(callback)) {
-        this.listeners[eventType].delete(callback);
-        if (this.listeners[eventType].size === 0) {
-          delete this.listeners[eventType];
-        }
-      }
-    }
-  }
-  globals_observer = Observer;
-  return globals_observer;
-}
-var stripe_webhook;
-var hasRequiredStripe_webhook;
-function requireStripe_webhook() {
-  if (hasRequiredStripe_webhook) return stripe_webhook;
-  hasRequiredStripe_webhook = 1;
-  const Stripe = require$$0;
-  const stripe = Stripe(process.env.STRIPE_API_KEY);
-  const Webhook = requireGlobals_webhook();
-  requireGlobals_observer();
-  function middleware(req, res, next) {
-    next();
-  }
-  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);
-    }
-  }
-  stripe_webhook = StripeWebhook;
-  return stripe_webhook;
-}
-var payments_routes;
-var hasRequiredPayments_routes;
-function requirePayments_routes() {
-  if (hasRequiredPayments_routes) return payments_routes;
-  hasRequiredPayments_routes = 1;
-  const middlewareFactoryAuth = index.requireMiddlewares();
-  const controllerFactory = requirePayments_factory();
-  const controllerFactoryTickets = tickets_controller.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);
-      }
-    });
-    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;
-  queryProcessor.requireQueryProcessor();
-  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 = (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"
-            }
-          },
-          // Преобразование результатов
-          {
-            $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
-            }
-          }
-        ]);
-        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,
-          req.userId
-        );
+    },
+    {
+      timestamps: {
+        currentTime: () => Date.now()
       }
-      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(-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 {
-          await Wallet.create({
-            owner: new ObjectId(req.body.user),
-            balances: [{ name: "WDT", amount: +amount, locked_amount: 0 }]
-          });
+    },
+    { strict: false }
+  );
+  return db.mongoose.model("Reward", RewardSchema);
+};
+const ModelWallet = (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";
+        },
+        required: true
+      },
+      balances: [
+        {
+          name: String,
+          // Name of currency
+          amount: Number,
+          // Amount
+          locked_amount: Number
         }
-      }
-      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
-    };
-  };
-  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 = index.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
-    );
-  };
-  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);
-    }
-  }
-  wallet_server$1 = {
-    initialize: initializePayments,
-    models: {
-      ModelWallet,
-      ModelPayment,
-      ModelReward
+      ]
     },
-    routes: {
-      RoutesPayments,
-      RoutesRewards
+    {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
     },
-    controllers: {
-      FactoryPayments
-    }
-  };
-  return wallet_server$1;
+    { strict: false }
+  );
+  return db.mongoose.model("Wallet", WalletSchema);
+};
+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);
+  }
 }
-var wallet_serverExports = requireWallet_server();
-const wallet_server = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(wallet_serverExports);
-module.exports = wallet_server;
+const models = {
+  ModelWallet,
+  ModelPayment,
+  ModelReward
+};
+const routes = {
+  RoutesPayments,
+  RoutesRewards
+};
+const controllers = {
+  FactoryPayments: controllerFactory
+};
+const wallet_server = {
+  initialize: initializePayments,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  wallet_server as default,
+  initializePayments as initialize,
+  models,
+  routes
+};