help me

[Mochikennedy]

const price_data = ( coindoc[0].price )
                                   ^

TypeError: Cannot read properties of undefined (reading 'price')

[angelhtml]

Hi,thanks for calling me 😊

1️⃣step one

just create a json file with the name of few coin you want
like this:

then replace your json url here (line 83)

2️⃣step two

go to your mongoDB collection and for each coin whose name you wrote in the json file, insert a document that includes the coin name(coin) and present price(price) and a random position(position) (Sell or Buy)
(for example this one for XLMUSDT)

✅run the code,Your problem will be solved

[braverynew]

Hi angel!
In this step 2. Do I have input current price or price:"" only and your app automatic get price from web? I had put only name of the symbol.
here my insert document in mongo
_id:xxxxxx
price:""
coin:"ADAUSDT"
posittion:"Buy" ---> it mean only buy signal?
Thanks

[angelhtml]

Hi
first of all you should put current price and then app will get automatically price from coinex api and posittion:"Buy" is means a buy signal

[braverynew]

if I want both of positions I have to insert 2 documents for each coin right? And each coin I input same price ok? I have 10 coins in list, so I have to input price of each coin?

[angelhtml]

if I want both of positions I have to insert 2 documents for each coin right? And each coin I input same price ok? I have 10 coins in list, so I have to input price of each coin?

-for both position you need insert only one document (just put position "Buy" or "Sell" for example: "position": "Sell")
-for each coin you need only one document
-if you have 10 coins you must insert 10 documents with separated price
this's very important to run the bot for the first time, it must already have the coins data

[Eagle84]

Hi, thank you for the hard work.
I have configured everything and it seems to work (partially).
I am getting the following error:

Express server is running on port 3520
list: { code: 0, data: [ 'BITCOINUSDT' ], message: 'OK' }
Your DB is connected now
Error while reading the file: Indicator is not defined
then after fixing the error i am getting another error
Error while reading the file: Supertrend is not a constructor

Here is the code:

const MOngoDB_cluster = "XXXXX";
const Discord_token = 'XXXXX';
const Discord_Channel_Id = 'XXXXX';

const axios = require('axios').default;
const fs = require('fs');
const {Client, Intents} = require('discord.js');
const client = new Client({
    intents: [Intents.FLAGS.GUILDS, Intents.FLAGS.GUILD_MESSAGES]
});

const { RSI, EMA, ROC, Supertrend } = require('technicalindicators');




const chalk = require('chalk');
const express = require('express');
const app = express();
const cors = require('cors');
const mongoose = require('mongoose');
mongoose.set('strictQuery', false);
app.use(cors());
app.use(express.json());
app.use(express.static('public'));

// MongoDB connection
mongoose.connect(MOngoDB_cluster, () => {
    console.log('Your DB is connected now');
});

let last_balance = 0;

async function tick() {
  
 
  try {
    //const list = await axios.get('https://api.coinex.com/v1/market/list')
    const filePath = 'C:\\Users\\igalb\\Desktop\\Trade\\Discord_Trading_Bot\\exchange.json';
    const rawData = fs.readFileSync(filePath);
    const list = JSON.parse(rawData);

      console.log('list:', list);

      if (Array.isArray(list.data)) { 
          let listOfUsdt = [];

          for (let index = 0; index < list.data.length; index++) {
              if (list.data[index].charAt(list.data[index].length - 1) == "T") {
                  await listOfUsdt.push(list.data[index]);
              }
          }

          for (let index = 0; index < listOfUsdt.length; index++) {
              const data15 = await axios.get(`https://api.coinex.com/v1/market/kline?market=${
                  listOfUsdt[index]
              }&limit=10000&type=1hour`);
              const highValues = data15.data.data.map(e => e[3] * 1)
              const lowValues = data15.data.data.map(e => e[4] * 1)
              const clossingValues = data15.data.data.map(e => e[2] * 1)
              const volumeValues = data15.data.data.map(e => e[5] * 1)
              const openingValues = data15.data.data.map(e => e[1] * 1)
              const date = data15.data.data.map(e => e[0] * 1)


              const data = await axios.get(`https://api.coinex.com/v1/market/kline?market=${
                  listOfUsdt[index]
              }&limit=1&type=1hour`)
              const data2 = await axios.get(`https://api.coinex.com/v1/market/kline?market=${
                  listOfUsdt[index]
              }&limit=60&type=1hour`)
              let sumRsi = RSI.calculate({values: clossingValues, period: 2})
              let last = data.data.data[0][2]
              var lastrsi = sumRsi[997]
              var beforelastrsi = sumRsi[996]
              var Rsisubtract = lastrsi - beforelastrsi
              var Rsi_Buy_position = (lastrsi > beforelastrsi)
              var Rsi_Sell_position = (lastrsi < beforelastrsi)
              var Rsi_Sell = (lastrsi >= 70 && beforelastrsi >= 70)
              var Rsi_Buy = (lastrsi <= 30 && beforelastrsi <= 30)


              // =========ROC===============
              let Roc = ROC.calculate({period: 12, values: clossingValues})
              var Roc1 = Roc[987]
              var Roc2 = Roc[986]
              var RocSubtract = Roc1 - Roc2
              var Roc_Buy_position = (Roc1 > Roc2)
              var Roc_Sell_position = (Roc1 < Roc2)
              var Roc_Buy = (Roc1 < 0)
              var Roc_Sell = (0 < Roc1)
              // ===========================


              let old_history = data2.data.data[0][0]
              let new_history = data2.data.data[0][5]
              let fee = last * 0.3 / 100


              let ema = new EMA({values: clossingValues, period: 8})
              let emaResult = EMA.calculate({values: ema.result, period: 8})
              let emamintprice = last - JSON.stringify(emaResult[985])
              let ema_history1 = emaResult[985]
              let ema_history2 = emaResult[984]
              let ema_history_sell = (ema_history1 - ema_history2 < 0)
              let ema_history_buy = (ema_history1 - ema_history2 > 0)
              let EMA_Buy = (emamintprice >= 0)
              let EMA_Sell = (emamintprice < 0)

              let EMa_percent = last / emaResult[985]
              let trade_percent_pos = (0.98 <= EMa_percent && EMa_percent < 1)
              let trade_percent_nev = (EMa_percent >= 1)


              // ======================mongo db
              const coinsSchema = {
                  price: Number,
                  coin: String,
                  date: String,
                  position: String,
                  Net_profit: Number,
                  time: String,
                  position_State: String,

                  Atr_value: Number
              }
              const coinlist = mongoose.models.coinlist || mongoose.model('coinlist', coinsSchema)
              const coindoc = await coinlist.find({coin: `${listOfUsdt[index]}`}).sort({_id: -1}).limit(1)

              const price_data = (coindoc[0].price)
              let blance = price_data
              let blance_check = (blance == new_history)
              let total_profit_nev = await new_history - blance - fee
              let total_profit_pos = await blance - new_history - fee
              let profit_state_nev = (total_profit_nev > 0)
              let profit_state_pos = (total_profit_pos > 0)
              let Net_Profit = 0
              const your_PS = (coindoc[0].position_State)

              let position_state_sell = (your_PS == 'true')
              let position_state_buy = (your_PS == 'false')

              // ===================supertrend=====================
              const superData = []
              for (let st = 0; st < 1000; st++) {
                  const a = [
                      date[st],
                      openingValues[st],
                      highValues[st],
                      lowValues[st],
                      clossingValues[st],
                      volumeValues[st]
                  ]
                  superData.push(a)
              }
              const newStudyATR = new Supertrend();
              const trend = newStudyATR.calculate(superData, {
                  period: 14,
                  multiplier: 1.5
              });
              console.log(trend[999])

              const direction_Buy = (trend[999].Supertrend.Direction > 0)
              const direction_Sell = (trend[999].Supertrend.Direction < 0)
              const sumTrueRange = (trend[999].ATR.SumTrueRange < 0.01)

              const Supertrande_stoploss_Buy = (last > trend[999].Supertrend.Down + trend[999].Supertrend.Down * 0.5 / 100) // buy lower value
              const Supertrande_stoploss_Sell = (last < trend[999].Supertrend.Up - trend[999].Supertrend.Up * 0.5 / 100)

              console.log(`range: ${
                  trend[999].ATR.SumTrueRange
              },${sumTrueRange}\n stop_buy${
                  coindoc[0].Atr_value
              },now:${
                  trend[999].Supertrend.Up - trend[999].Supertrend.Up * 0.5 / 100
              },${Supertrande_stoploss_Buy},sell:${Supertrande_stoploss_Sell}`)


              const super_1 = trend[999].Supertrend.Direction
              const super_2 = trend[998].Supertrend.Direction
              const super_3 = trend[997].Supertrend.Direction
              const super_4 = trend[996].Supertrend.Direction
              const super_5 = trend[995].Supertrend.Direction
              const sum_true_range = trend[999].ATR.SumTrueRange


              // =======================STOP-LOSS============================
              var risk = 1.5
              // sell
              var detriment_sell = total_profit_nev
              var loss_sell = detriment_sell / blance * 100
              var loss_protcol_sell = (loss_sell + risk < 0)
              // buy
              var detriment_buy = total_profit_pos
              var loss_buy = detriment_buy / blance * 100
              var loss_protcol_buy = (loss_buy + risk < 0)
              // ============================================================
              var psp = 0
              if (profit_state_pos == true) {
                  psp = 20
              }

              var tpn = 0
              if (Roc_Buy_position == true) {
                  var tpn = 20
              }

              var psn = 0
              if (profit_state_nev == true) {
                  psn = 20
              }

              var tpp = 0
              if (Roc_Sell_position == true) {
                  tpp = 20
              }

              var eb = 0
              if (Roc_Buy == true) {
                  eb = 20
              }

              var es = 0
              if (Roc_Sell == true) {
                  es = 20
              }

              var st = '0'
              if (position_state_sell == true) {
                  st = 'Sell'
              } else {
                  st = 'Buy'
              }

              var ehs = 0
              if (Rsi_Sell == true) {
                  ehs = 20
              }

              var ehb = 0
              if (Rsi_Buy == true) {
                  ehb = 20
              }

              // RSI
              var rbp = 0
              if (Roc_Buy_position == true) {
                  rbp = 20
              }
              var rsp = 0
              if (Roc_Sell_position == true) {
                  rsp = 20
              }

              var BUY_state = Math.floor(psp) + Math.floor(tpn) + Math.floor(eb) + Math.floor(ehb) + Math.floor(rbp)
              var SELL_state = Math.floor(psn) + Math.floor(tpp) + Math.floor(es) + Math.floor(ehs) + Math.floor(rsp)

              var BUY_NETprofit = (total_profit_pos / last) * 100
              var SELL_NETprofit = (total_profit_nev / last) * 100

              const infoSchema = {
                  coin: String,
                  price: Number,
                  position: String,
                  ema1: Number,
                  ema2: Number,
                  emapercent: Number,
                  ema_subtract: Number,
                  emas: Number,
                  emab: Number,
                  buy_state: Number,
                  sell_state: Number,
                  buy_netprofit: Number,
                  sell_netprofit: Number,
                  RSI_per: Number,
                  ROC1: Number,
                  ROC2: Number,
                  Roc_Subtract: Number,
                  super1: Number,
                  super2: Number,
                  super3: Number,
                  super4: Number,
                  super5: Number,

                  Sum_true_range: Number
              }
              const coin = listOfUsdt[index]
              const price = last
              const position = st
              const ema1 = ema_history1
              const ema2 = ema_history2
              const emapercent = EMa_percent
              const ema_subtract = emamintprice
              const emas = ehs
              const emab = ehb
              const buy_state = BUY_state
              const sell_state = SELL_state
              const buy_netprofit = BUY_NETprofit
              const sell_netprofit = SELL_NETprofit
              const RSI_per = lastrsi
              const ROC1 = Roc1
              const ROC2 = Roc2
              const Roc_Subtract = RocSubtract
              const super1 = super_1
              const super2 = super_2
              const super3 = super_3
              const super4 = super_4
              const super5 = super_5

              const Sum_true_range = sum_true_range

              const informations = mongoose.models.informations || mongoose.model('informations', infoSchema)
              const infos = new informations({
                  coin,
                  price,
                  position,
                  ema1,
                  ema2,
                  emapercent,
                  ema_subtract,
                  emas,
                  emab,
                  buy_state,
                  sell_state,
                  buy_netprofit,
                  sell_netprofit,
                  RSI_per,
                  ROC1,
                  ROC2,
                  Roc_Subtract,
                  super1,
                  super2,
                  super3,
                  super4,
                  super5,

                  Sum_true_range
              });

              if ( /*25<= sumRsi[967] && sumRsi[967] <= 30   &&*/
              ( /*EMA_Buy == true  &&  trade_percent_nev == true  &&*/
              profit_state_pos == true && position_state_buy == true /*&& ema_history_buy == true*/
                      && Roc_Buy_position == true && Roc_Buy == true && direction_Buy == true) || ( /*EMA_Buy == true  &&  trade_percent_nev == true   &&*/
              position_state_buy == true /*&& ema_history_buy == true*/
                      && Roc_Buy_position == true && Supertrande_stoploss_Buy == true && direction_Buy == true)) {
                  let Net_Profit = blance - new_history - fee
                  client.channels.cache.get(Discord_Channel_Id).send(`>>> Name:  **${
                      listOfUsdt[index]
                  }**\n :green_circle: Buy : ${last}\n :round_pushpin: ${
                      (Net_Profit / blance) * 100
                  }\n :arrow_up_small: ${Net_Profit}\n :recycle:  ${
                      emaResult[985]
                  }\n :page_facing_up: Fee:${fee} `)

                  const coinsSchema = {
                      price: Number,
                      coin: String,
                      date: String,
                      position: String,
                      Net_profit: Number,
                      time: String,
                      position_State: String,

                      Atr_value: Number
                  }

                  const price = last
                  const coin = listOfUsdt[index]
                  const date = Date.now()
                  const position = "Buy"
                  const Net_profit = Net_Profit
                  const time = new Date()
                  const position_State = true

                  const Atr_value = trend[999].ATR.Value * 75 / 100


                  const coinlist = mongoose.models.coinlist || mongoose.model('coinlist', coinsSchema)

                  const coindata = new coinlist({
                      price,
                      coin,
                      date,
                      position,
                      Net_profit,
                      time,
                      position_State,

                      Atr_value
                  });

                  coindata.save()


              } else if ( /*70<= sumRsi[967] && sumRsi[967] <= 75 &&*/
              ( /*EMA_Sell == true  &&  trade_percent_pos == true  &&*/
              profit_state_nev == true && position_state_sell == true /*&& ema_history_sell == true*/
                      && Roc_Sell_position == true && Roc_Sell == true && direction_Sell == true) || ( /*EMA_Sell == true  &&  trade_percent_pos == true   &&*/
              position_state_sell == true /*&& ema_history_sell == true*/
                      && Roc_Sell_position == true && Supertrande_stoploss_Sell == true && direction_Sell == true)) {
                  Net_Profit = new_history - blance - fee
                  client.channels.cache.get(Discord_Channel_Id).send(` >>> Name: **${
                      listOfUsdt[index]
                  }**\n :red_circle: sell : ${last}\n :round_pushpin: ${
                      (Net_Profit / blance) * 100
                  }\n :arrow_up_small: ${Net_Profit}\n :recycle:  ${
                      emaResult[985]
                  }\n :page_facing_up: Fee:${fee}`)
                  const coinsSchema = {
                      price: Number,
                      coin: String,
                      date: String,
                      position: String,
                      Net_profit: Number,
                      time: String,
                      position_State: String,

                      Atr_value: Number
                  }

                  const price = last
                  const coin = listOfUsdt[index]
                  const date = Date.now()
                  const position = "Sell"
                  const Net_profit = Net_Profit
                  const time = new Date()
                  const position_State = false

                  const Atr_value = trend[999].ATR.Value * 75 / 100


                  const coinlist = mongoose.models.coinlist || mongoose.model('coinlist', coinsSchema)

                  const coindata = new coinlist({
                      price,
                      coin,
                      date,
                      position,
                      Net_profit,
                      time,
                      position_State,

                      Atr_value
                  });

                  coindata.save()


              } else {}


              const update = {
                  price: last,
                  position: st,
                  ema1: ema_history1,
                  ema2: ema_history2,
                  emapercent: EMa_percent,
                  ema_subtract: emamintprice,
                  emab: ehb,
                  emas: ehs,
                  buy_state: BUY_state,
                  sell_state: SELL_state,
                  buy_netprofit: BUY_NETprofit,
                  sell_netprofit: SELL_NETprofit,
                  RSI_per: lastrsi,
                  ROC1: Roc1,
                  ROC2: Roc2,
                  Roc_Subtract: RocSubtract,
                  super1: super_1,
                  super2: super_2,
                  super3: super_3,
                  super4: super_4,
                  super5: super_5,

                  Sum_true_range: sum_true_range
              };
              await informations.findOneAndUpdate({
                  coin: listOfUsdt[index]
              }, update)
              // infos.save()
              app.get("/xlm", async (req, res) => {
                  const coinlist = mongoose.models.coinlist || mongoose.model('coinlist', coinsSchema)
                  const coindoc = await coinlist.find({coin: 'XLMUSDT'}).sort({_id: -1}).exec((err, coinlist) => {
                      res.send(coinlist)
                  });
              });

              app.get("/other", async (req, res) => {
                  const informations = mongoose.models.informations || mongoose.model('informations', infoSchema)
                  const infodoc = await informations.find({coin: 'XLMUSDT'}).exec((err, informations) => {
                      res.send(informations)
                  });
              });

              app.get("/doge", async (req, res) => {
                  const coinlist = mongoose.models.coinlist || mongoose.model('coinlist', coinsSchema)
                  const coindoc = await coinlist.find({coin: 'DOGEUSDT'}).sort({_id: -1}).exec((err, coinlist) => {
                      res.send(coinlist)
                  });
              });

              app.get("/otherdoge", async (req, res) => {
                  const informations = mongoose.models.informations || mongoose.model('informations', infoSchema)
                  const infodoc = await informations.find({coin: 'DOGEUSDT'}).exec((err, informations) => {
                      res.send(informations)
                  });
              });

              app.get("/shib", async (req, res) => {
                  const coinlist = mongoose.models.coinlist || mongoose.model('coinlist', coinsSchema)
                  const coindoc = await coinlist.find({coin: 'SHIBUSDT'}).sort({_id: -1}).exec((err, coinlist) => {
                      res.send(coinlist)
                  });
              });

              app.get("/othershib", async (req, res) => {
                  const informations = mongoose.models.informations || mongoose.model('informations', infoSchema)
                  const infodoc = await informations.find({coin: 'SHIBUSDT'}).exec((err, informations) => {
                      res.send(informations)
                  });
              });

          }
      } else {
          console.log('Invalid or empty list data');
      }
  } catch (error) {
      console.error('Error while reading the file:', error.message);
  }
}

client.on("ready", () => {
    tick();

});

function run() {
    setInterval(() => {
        tick();
    }, 1000 * 60 * 0.5);
}

try {
    run();
} catch (err) {
    console.log(err);
}
client.login(Discord_token);
app.listen(3520, function () {
    console.log('Express server is running on port 3520');
});`

Please advise

[angelhtml]

Hi, Thanks a lot 👍

you can define the Indicators with import this library
https://www.npmjs.com/package/technicalindicators

const Stock = require("stock-technical-indicators")
const Indicator = Stock.Indicator

and about the Supertrend you should remove Supertrend from technicalindicators, cause this library didn't support the Supertrend

const { RSI, EMA, ROC } = require('technicalindicators');

and then import the stock-technical-indicators library
https://www.npmjs.com/package/stock-technical-indicators

const { Supertrend } = require("stock-technical-indicators/study/Supertrend")