WIP1&2

jobs/calculate_community_earnings.js → jobs/calculate_community_earnings.ts

@@ -12,9 +12,9 @@ const calculateEarnings = async () => {
     for (const order of orders) {
       const amount = order.amount;
       const fee = order.fee;
-      const botFee = order.bot_fee || parseFloat(process.env.MAX_FEE);
+      const botFee = order.bot_fee || Number(process.env.MAX_FEE);
       const communityFeePercent =
-        order.community_fee || parseFloat(process.env.FEE_PERCENT);
+        order.community_fee || Number(process.env.FEE_PERCENT);
       const maxFee = amount * botFee;
       const communityFee = fee - maxFee * communityFeePercent;
       const earnings = earningsMap.get(order.community_id) || [0, 0];
@@ -36,7 +36,7 @@ const calculateEarnings = async () => {
       );
     }
   } catch (error) {
-    const message = error.toString();
+    const message = String(error);
     logger.error(`calculateEarnings catch error: ${message}`);
   }
 };

jobs/cancel_orders.js → jobs/cancel_orders.ts

@@ -1,15 +1,18 @@
+import { Telegraf } from "telegraf";
+import { MainContext } from "../bot/start";
+
 const { User, Order } = require('../models');
 const { cancelShowHoldInvoice, cancelAddInvoice } = require('../bot/commands');
 const messages = require('../bot/messages');
 const { getUserI18nContext, holdInvoiceExpirationInSecs } = require('../util');
 const logger = require('../logger');
 
-const cancelOrders = async bot => {
+const cancelOrders = async (bot: Telegraf<MainContext>) => {
   try {
     const holdInvoiceTime = new Date();
     holdInvoiceTime.setSeconds(
       holdInvoiceTime.getSeconds() -
-        parseInt(process.env.HOLD_INVOICE_EXPIRATION_WINDOW)
+        Number(process.env.HOLD_INVOICE_EXPIRATION_WINDOW)
     );
     // We get the orders where the seller didn't pay the hold invoice before expired
     // or where the buyer didn't add the invoice
@@ -70,7 +73,7 @@ const cancelOrders = async bot => {
     // Now we cancel orders expired
     // ==============================
     orderTime = new Date();
-    let orderExpirationTime = parseInt(
+    let orderExpirationTime = Number(
       process.env.ORDER_PUBLISHED_EXPIRATION_WINDOW
     );
     orderExpirationTime = orderExpirationTime + orderExpirationTime * 0.2;

jobs/communities.js → jobs/communities.ts

@@ -1,12 +1,15 @@
+import { Telegraf } from "telegraf";
+import { MainContext } from "../bot/start";
+
 const { Order, Community } = require('../models');
 const logger = require('../logger');
 
-const deleteCommunity = async bot => {
+const deleteCommunity = async (bot: Telegraf<MainContext>) => {
   try {
     const communities = await Community.find();
     for (const community of communities) {
       // Delete communities with COMMUNITY_TTL days without a successful order
-      const days = 86400 * parseInt(process.env.COMMUNITY_TTL);
+      const days = 86400 * Number(process.env.COMMUNITY_TTL);
       const time = new Date();
       time.setSeconds(time.getSeconds() - days);
       // If is a new community we don't do anything
@@ -26,7 +29,7 @@ const deleteCommunity = async bot => {
       }
     }
   } catch (error) {
-    const message = error.toString();
+    const message = String(error);
     logger.error(`deleteCommunity catch error: ${message}`);
   }
 };

jobs/delete_published_orders.js → jobs/delete_published_orders.ts

@@ -1,13 +1,16 @@
+import { Telegraf } from "telegraf";
+import { MainContext } from "../bot/start";
+
 const { Order } = require('../models');
 const { deleteOrderFromChannel } = require('../util');
 const logger = require('../logger');
 
-const deleteOrders = async bot => {
+const deleteOrders = async (bot: Telegraf<MainContext>) => {
   try {
     const windowTime = new Date();
     windowTime.setSeconds(
       windowTime.getSeconds() -
-        parseInt(process.env.ORDER_PUBLISHED_EXPIRATION_WINDOW)
+        Number(process.env.ORDER_PUBLISHED_EXPIRATION_WINDOW)
     );
     // We get the pending orders where time is expired
     const pendingOrders = await Order.find({
@@ -25,7 +28,7 @@ const deleteOrders = async bot => {
       await deleteOrderFromChannel(orderCloned, bot.telegram);
     }
   } catch (error) {
-    const message = error.toString();
+    const message = String(error);
     logger.error(`deleteOrders catch error: ${message}`);
   }
 };

jobs/node_info.js → jobs/node_info.ts

@@ -1,8 +1,11 @@
+import { Telegraf } from "telegraf";
+import { MainContext } from "../bot/start";
+
 const { Config } = require('../models');
 const { getInfo } = require('../ln');
 const logger = require('../logger');
 
-const info = async bot => {
+const info = async (bot: Telegraf<MainContext>) => {
   try {
     const config = await Config.findOne({});
     const info = await getInfo();
@@ -12,7 +15,7 @@ const info = async bot => {
     config.node_uri = info.uris[0];
     await config.save();
   } catch (error) {
-    const message = error.toString();
+    const message = String(error);
     logger.error(`node info catch error: ${message}`);
   }
 };

ln/connect.js → ln/connect.ts

@@ -1,6 +1,6 @@
-const fs = require('fs');
-const path = require('path');
-const lightning = require('lightning');
+import * as fs from 'fs';
+import path = require('path');
+import * as lightning from "lightning";
 const logger = require('../logger');
 
 const { authenticatedLndGrpc } = lightning;
@@ -47,4 +47,4 @@ const { lnd } = authenticatedLndGrpc({
   socket,
 });
 
-module.exports = lnd;
+export default lnd;

ln/hold_invoice.js → ln/hold_invoice.ts

@@ -1,26 +1,26 @@
-const { createHash, randomBytes } = require('crypto');
-const lightning = require('lightning');
-const lnd = require('./connect');
+import { randomBytes, createHash } from 'crypto';
+import * as lightning from "lightning";
+import lnd from './connect'
 const logger = require('../logger');
 
-const createHoldInvoice = async ({ description, amount }) => {
+const createHoldInvoice = async (description: string, amount: number ) => {
   try {
     const randomSecret = () => randomBytes(32);
-    const sha256 = buffer => createHash('sha256').update(buffer).digest('hex');
+    const sha256 = (buffer: Buffer): string => createHash('sha256').update(buffer).digest('hex');
     // We create a random secret
     const secret = randomSecret();
     const expiresAt = new Date();
     expiresAt.setSeconds(expiresAt.getSeconds() + 3600);
 
     const hash = sha256(secret);
-    const cltv_delta = parseInt(process.env.HOLD_INVOICE_CLTV_DELTA);
+    const cltv_delta = Number(process.env.HOLD_INVOICE_CLTV_DELTA);
     const { request, id } = await lightning.createHodlInvoice({
       cltv_delta,
       lnd,
       description,
       id: hash,
       tokens: amount,
-      expires_at: expiresAt,
+      expires_at: expiresAt.toISOString(),
     });
 
     // We sent back the response hash (id) to be used on testing
@@ -30,23 +30,23 @@ const createHoldInvoice = async ({ description, amount }) => {
   }
 };
 
-const settleHoldInvoice = async ({ secret }) => {
+const settleHoldInvoice = async ( secret: string ) => {
   try {
     await lightning.settleHodlInvoice({ lnd, secret });
   } catch (error) {
     logger.error(error);
   }
 };
 
-const cancelHoldInvoice = async ({ hash }) => {
+const cancelHoldInvoice = async ( hash: string ) => {
   try {
     await lightning.cancelHodlInvoice({ lnd, id: hash });
   } catch (error) {
     logger.error(error);
   }
 };
 
-const getInvoice = async ({ hash }) => {
+const getInvoice = async ( hash: string ) => {
   try {
     return await lightning.getInvoice({ lnd, id: hash });
   } catch (error) {

ln/info.js → ln/info.ts

@@ -1,13 +1,11 @@
-const lightning = require('lightning');
-const lnd = require('./connect');
+import * as lightning from "lightning";
+import lnd from './connect'
 const logger = require('../logger');
 
-const getInfo = async () => {
+export const getInfo = async () => {
   try {
     return await lightning.getWalletInfo({ lnd });
   } catch (error) {
     logger.error(error);
   }
 };
-
-module.exports = { getInfo };

ln/resubscribe_invoices.js → ln/resubscribe_invoices.ts

@@ -1,13 +1,15 @@
-const { getInvoices } = require('lightning');
-const lnd = require('./connect');
+import { Telegraf } from 'telegraf';
+import { MainContext } from "../bot/start";
+import { getInvoices, GetInvoicesResult } from 'lightning';
+import lnd from './connect';
 const subscribeInvoice = require('./subscribe_invoice');
 const { Order } = require('../models');
 const logger = require('../logger');
 
-const resubscribeInvoices = async bot => {
+const resubscribeInvoices = async (bot: Telegraf<MainContext>) => {
   try {
     let invoicesReSubscribed = 0;
-    const isHeld = invoice => !!invoice.is_held;
+    const isHeld = (invoice: any) => !!invoice.is_held;
     const unconfirmedInvoices = (
       await getInvoices({
         lnd,
@@ -29,7 +31,7 @@ const resubscribeInvoices = async bot => {
     }
     logger.info(`Invoices resubscribed: ${invoicesReSubscribed}`);
   } catch (error) {
-    logger.error(`ResuscribeInvoice catch: ${error.toString()}`);
+    logger.error(`ResuscribeInvoice catch: ${String(error)}`);
     return false;
   }
 };

ln/subscribe_invoice.js → ln/subscribe_invoice.ts

@@ -1,13 +1,15 @@
-const { subscribeToInvoice } = require('lightning');
+import { Telegraf } from "telegraf";
+import { MainContext } from "../bot/start";
+import {subscribeToInvoice} from 'lightning'
 const { Order, User } = require('../models');
 const { payToBuyer } = require('./pay_request');
-const lnd = require('./connect');
+import lnd from "./connect";
 const messages = require('../bot/messages');
 const ordersActions = require('../bot/ordersActions');
 const { getUserI18nContext, getEmojiRate, decimalRound } = require('../util');
 const logger = require('../logger');
 
-const subscribeInvoice = async (bot, id, resub) => {
+const subscribeInvoice = async (bot: Telegraf<MainContext>, id: string, resub: boolean) => {
   try {
     const sub = subscribeToInvoice({ id, lnd });
     sub.on('invoice_updated', async invoice => {