@ozdao/martyrs 0.2.547 → 0.2.549

package/dist/wallet.server.cjs

@@ -1,528 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const QRCode = require("qrcode");
-const index = require("./index-BFxqqmgh.cjs");
-const tickets_controller = require("./tickets.controller-9zoaVPcx.cjs");
-const globals_observer = require("./globals.observer-C_FYclgV.cjs");
-const Stripe = require("stripe");
-const bignumber_js = require("bignumber.js");
-const mongoose = require("mongoose");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const QRCode__namespace = /* @__PURE__ */ _interopNamespaceDefault(QRCode);
-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__namespace.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 globals_observer.ObserverNamespaced();
-  new StripeWebhook(app, db, observer);
-  const controller = controllerFactory(db);
-  console.log("payments ticket", publicPath);
-  const controllerTickets = tickets_controller.controllerFactory(db, publicPath);
-  index.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: mongoose.Types }.Types.ObjectId;
-bignumber_js.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_js.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_js.BigNumber("10").plus(new bignumber_js.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_js.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_js.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 });
-        } 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 } = index.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
-      },
-      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;
-};
-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";
-        },
-        required: true
-      },
-      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);
-};
-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
-        }
-      ]
-    },
-    {
-      timestamps: {
-        currentTime: () => Date.now()
-      }
-    },
-    { 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);
-  }
-}
-const models = {
-  ModelWallet,
-  ModelPayment,
-  ModelReward
-};
-const routes = {
-  RoutesPayments,
-  RoutesRewards
-};
-const controllers = {
-  FactoryPayments: controllerFactory
-};
-const wallet_server = {
-  initialize: initializePayments,
-  models,
-  routes,
-  controllers
-};
-exports.controllers = controllers;
-exports.default = wallet_server;
-exports.initialize = initializePayments;
-exports.models = models;
-exports.routes = routes;