feat: add /scheduleorder and /cancelschedule for recurring auto-republishing orders

.env-sample

@@ -135,3 +135,22 @@ MONITOR_URL=''
 MONITOR_AUTH_TOKEN=''
 # Bot name identifier sent with heartbeats (default: lnp2pBot)
 MONITOR_BOT_NAME='lnp2pBot'
+
+# Scheduled orders: number of publication cycles per schedule (default: 10)
+REPUBLISH_ORDER_DAYS='10'
+# Anti-spam requirements to create scheduled orders (all optional, defaults shown)
+# Max active schedules a single user can hold at once
+SCHEDULE_MAX_PER_USER='3'
+# Minimum account age (days using the bot) required to schedule orders
+SCHEDULE_MIN_ACCOUNT_AGE_DAYS='7'
+# Minimum number of completed trades required to schedule orders
+SCHEDULE_MIN_COMPLETED_ORDERS='5'
+# Minimum traded volume in sats required to schedule orders (0 disables the check)
+SCHEDULE_MIN_VOLUME='0'
+# Minimum reputation (0-5) required to schedule orders (enforced only if the user has reviews)
+SCHEDULE_MIN_RATING='4'
+# Minimum order completion rate (SUCCESS over taken orders), 0-1
+SCHEDULE_MIN_COMPLETION_RATE='0.9'
+# Max days a maker may go without completing any order before their schedules are removed as dormant (0 disables).
+# Note: taken orders expire in ~27h (see ORDER_PUBLISHED_EXPIRATION_WINDOW)
+SCHEDULE_MAX_DAYS_WITHOUT_COMPLETION='7'

bot/middleware/stage.ts

@@ -2,6 +2,7 @@ import { Scenes } from 'telegraf';
 import * as CommunityModule from '../modules/community';
 import * as OrdersModule from '../modules/orders';
 import * as UserModule from '../modules/user';
+import { scheduleOrderWizard } from '../modules/schedule';
 import { CommunityContext } from '../modules/community/communityContext';
 import {
   addInvoiceWizard,
@@ -28,6 +29,7 @@ export const stageMiddleware = () => {
     addInvoicePHIWizard,
     OrdersModule.Scenes.createOrder,
     UserModule.Scenes.Settings,
+    scheduleOrderWizard,
   ];
   scenes.forEach(addGenericCommands);
   const stage = new Scenes.Stage(scenes, {

bot/modules/orders/takeOrder.ts

@@ -18,7 +18,6 @@ import {
   validateTakeSellOrder,
   validateUserWaitingOrder,
 } from '../../validations';
-
 const OrderEvents = require('../../modules/events/orders');
 
 export const takeOrderActionValidation = async (
@@ -112,7 +111,6 @@ export const takebuy = async (
       OrderEvents.orderUpdated(order);
 
       await deleteOrderFromChannel(order, bot.telegram);
-
       await messages.beginTakeBuyMessage(ctx, bot, user, order);
     });
   } catch (error) {

bot/modules/schedule/commands.ts

@@ -0,0 +1,161 @@
+import { Types } from 'mongoose';
+import { CommunityContext } from '../community/communityContext';
+import { ScheduledOrder } from '../../../models';
+import { validateSellOrder, validateBuyOrder } from '../../validations';
+import { getCurrency, sanitizeMD } from '../../../util';
+import { logger } from '../../../logger';
+import { SCHEDULE_ORDER } from './scenes';
+import { formatDays } from './messages';
+import { checkScheduleRequirements } from './helpers';
+
+export const scheduleorder = async (ctx: CommunityContext) => {
+  try {
+    // The scheduling flow is an interactive DM wizard
+    if (ctx.message?.chat.type !== 'private') return;
+
+    const text = (ctx.message as any)?.text || '';
+    const [, type, ...rest] = text.trim().split(/\s+/);
+
+    if (!type || !['buy', 'sell'].includes(type.toLowerCase())) {
+      return ctx.reply(ctx.i18n.t('scheduleorder_usage'));
+    }
+
+    const orderType = type.toLowerCase();
+
+    // Reuse the existing buy/sell validators by feeding them the order args
+    if (!ctx.state) (ctx as any).state = {};
+    if (!ctx.state.command) (ctx as any).state.command = {};
+    ctx.state.command.args = rest;
+
+    const params =
+      orderType === 'sell'
+        ? await validateSellOrder(ctx)
+        : await validateBuyOrder(ctx);
+
+    if (!params) return;
+
+    if (!getCurrency(params.fiatCode)) {
+      await ctx.reply(ctx.i18n.t('must_be_valid_currency'));
+      return;
+    }
+
+    // Gate creation behind anti-spam requirements (limit, seniority, completion
+    // rate, etc.) so only trusted makers can auto-publish orders.
+    const requirement = await checkScheduleRequirements(ctx.user);
+    if (!requirement.ok) {
+      await ctx.reply(ctx.i18n.t(requirement.messageKey!, requirement.params));
+      return;
+    }
+
+    await ctx.scene.enter(SCHEDULE_ORDER, {
+      user: ctx.user,
+      scheduleType: orderType,
+      amount: params.amount,
+      fiatAmount: params.fiatAmount,
+      fiatCode: params.fiatCode,
+      paymentMethod: params.paymentMethod,
+      priceMargin: params.priceMargin,
+    });
+  } catch (error) {
+    logger.error(error);
+  }
+};
+
+export const cancelschedule = async (ctx: CommunityContext) => {
+  try {
+    // Schedule management must stay in the private DM to avoid leaking or
+    // destroying schedule data from a group chat.
+    if (ctx.message?.chat.type !== 'private') return;
+
+    const user = ctx.user;
+    const args = ctx.state?.command?.args || [];
+    const scheduleId = args[0];
+
+    if (!scheduleId || !Types.ObjectId.isValid(scheduleId)) {
+      return ctx.reply(ctx.i18n.t('cancelschedule_usage'));
+    }
+
+    const schedule = await ScheduledOrder.findOne({
+      _id: scheduleId,
+      creator_id: user._id,
+      active: true,
+    });
+
+    if (!schedule) {
+      return ctx.reply(ctx.i18n.t('schedule_not_found'));
+    }
+
+    schedule.active = false;
+    await schedule.save();
+
+    await ctx.reply(ctx.i18n.t('schedule_cancelled', { scheduleId }));
+  } catch (error) {
+    logger.error(error);
+  }
+};
+
+export const listschedules = async (ctx: CommunityContext) => {
+  try {
+    // Schedule management must stay in the private DM to avoid leaking or
+    // destroying schedule data from a group chat.
+    if (ctx.message?.chat.type !== 'private') return;
+
+    const user = ctx.user;
+
+    const schedules = await ScheduledOrder.find({
+      creator_id: user._id,
+      active: true,
+    }).sort({ created_at: 1 });
+
+    if (schedules.length === 0) {
+      return ctx.reply(ctx.i18n.t('listschedules_empty'));
+    }
+
+    const items = schedules
+      .map(schedule => {
+        const hour = String(schedule.hour).padStart(2, '0');
+        const typeKey = schedule.type === 'buy' ? 'buying' : 'selling';
+        return ctx.i18n.t('schedule_list_item', {
+          scheduleId: String(schedule._id),
+          type: ctx.i18n.t(typeKey),
+          fiatAmount: schedule.fiat_amount.join('-'),
+          fiatCode: schedule.fiat_code,
+          paymentMethod: sanitizeMD(schedule.payment_method),
+          days: formatDays(schedule.days),
+          hour: `${hour}:00 UTC`,
+        });
+      })
+      .join('\n');
+
+    await ctx.reply(`${ctx.i18n.t('listschedules_header')}\n\n${items}`, {
+      parse_mode: 'Markdown',
+    });
+  } catch (error) {
+    logger.error(error);
+  }
+};
+
+export const cancelallschedules = async (ctx: CommunityContext) => {
+  try {
+    // Schedule management must stay in the private DM to avoid leaking or
+    // destroying schedule data from a group chat.
+    if (ctx.message?.chat.type !== 'private') return;
+
+    const user = ctx.user;
+
+    const result = await ScheduledOrder.updateMany(
+      { creator_id: user._id, active: true },
+      { active: false },
+    );
+
+    if (result.modifiedCount === 0) {
+      return ctx.reply(ctx.i18n.t('cancelallschedules_none'));
+    }
+
+    await ctx.reply(
+      ctx.i18n.t('all_schedules_cancelled', { count: result.modifiedCount }),
+    );
+  } catch (error) {
+    logger.error(error);
+  }
+};