coingecko.js

const express = require('express');
const router = express.Router();
const ethers = require('ethers');    

const _ABI = require('../dyco.json');
const _PROVIDER = ethers.getDefaultProvider('homestead'); 
const _DYCO_CONTRACT = "0x1d3A8D49cf9E4120766c10087e50525BcE08218A"

const UserStats = require('../model/stats');
const Totals = require('../model/totals');

const gql = require('graphql-tag');
const ApolloClient = require('apollo-boost').ApolloClient;
const fetch = require('cross-fetch/polyfill').fetch;
const createHttpLink = require('apollo-link-http').createHttpLink;
const InMemoryCache = require('apollo-cache-inmemory').InMemoryCache;
const client = new ApolloClient({
    link: createHttpLink({
        uri: "https://api.thegraph.com/subgraphs/name/daomaker/toll-bridge",
        fetch: fetch
    }),
    cache: new InMemoryCache()
});    



router.get('/', async (req, res) => {
  const stats = await UserStats.find();
  res.json(stats)
});


router.get('/seed', async function (req, res) {
    
  try {
          
  const queryFactoryContractData = await client.query({
      fetchPolicy: 'no-cache',
      query: gql`
      {
          dycos(where: { address: "0x1d3a8d49cf9e4120766c10087e50525bce08218a" }) {
            id
            address
            token
            distributionDelays
            distributionPercents
            releasesTimestamps   
            transferredTokens
            burnedTokens
          }
        }
      `,
  })     
  
  const messages = await UserStats.find();

  const items = messages.map(element => ( Number(Math.round(element.distributedTokens)) - Number(Math.round(element.naturallyReceivedTokens) ) ) );    
 
  let sum = items.reduce(function(accum, val) {return accum + Number(Math.round(val));}, 0);
  
  const freeCirculation = 16400000
 
  // const transferredtokens = queryFactoryContractData.data.dycos[0].transferredTokens
  const burned = queryFactoryContractData.data.dycos[0].burnedTokens
  
  try {
    await UserStats.deleteMany({});
  } catch (error) {
    throw error
  }

  
  const queryInvestorData = await client.query({
      fetchPolicy: 'no-cache',
      query: gql`
      {
          investors( first: 1000 ) {
              address
          }  
          }
      `,
  })     

  const item = queryInvestorData.data.investors.map( (element, i) => returnUserData(element.address, i, req) );
  let promises = await Promise.all(item).catch( error => {
   throw error   
  })
  
  let stats              = await UserStats.find();
  let stats_sum          = stats.map(element => ( Number(Math.round(element.distributedTokens)) - Number(Math.round(element.naturallyReceivedTokens) ) ) );    
  let stats_reducer        = stats_sum.reduce(function(accum, val) {return accum + Number(Math.round(val));}, 0);    
  let amt1               = freeCirculation + stats_reducer
  let circulating_supply = Math.round(amt1 - burned)
  let query   = {},
      update  = { circulating_supply, item: 1, },
      options = { upsert: true, new: true, setDefaultsOnInsert: true };

      // Find the document
      await Totals.findOneAndUpdate(query, update, options).catch( err => console.log(err));
  
  return res.json({ usersStats: promises })
  } catch (error) {
      return res.json({ error: error }) 
  }
});


router.get('/circulating-supply', async function (req, res) {
  const total = await Totals.findOne({ item: 1 });
  res.status(200).send(String(total.circulating_supply) );
});  


router.get('/total-supply', async function (req, res) {
  
  const queryData = await client.query({
       fetchPolicy: 'no-cache',
       query: gql`
       {
           dycos(where: { address: "0x1d3a8d49cf9e4120766c10087e50525bce08218a" }) {
             id
             address
             token
             distributionDelays
             distributionPercents
             releasesTimestamps   
             transferredTokens
             burnedTokens
           }
         }
       `,
   })   
   const burns = queryData.data.dycos[0].burnedTokens
   const totalSupply = 312000000 
   const returnValue = Math.round(totalSupply - burns)
   res.status(200).send(String(returnValue) );
});


function returnUserData(address, index, req) {
  const dyco = new ethers.Contract( _DYCO_CONTRACT, _ABI, _PROVIDER );  

  return new Promise( async (resolve, reject) => {
      try {
          let getUserStats = await dyco.functions.getUserStats( address ); 
            
          const user = {
              wallet: address,
              whitelisted: getUserStats.whitelisted,
              distributedTokens: ethers.utils.formatUnits( String(getUserStats.distributedTokens) ),
              maxTokens: ethers.utils.formatUnits( String(getUserStats.maxTokens ) ),
              naturallyReceivedTokens: ethers.utils.formatUnits( String( getUserStats.naturallyReceivedTokens ) ),
              receivedReleases: Number(getUserStats.receivedReleases )
          }            
          
          await UserStats.create({
              wallet: user.wallet,
              whitelisted: user.whitelisted,
              distributedTokens: user.distributedTokens,
              maxTokens: user.maxTokens,
              naturallyReceivedTokens: user.naturallyReceivedTokens,
              receivedReleases: user.receivedReleases,  
              pendingDelete: false         
            });            
          resolve(user)
      } catch (error) {
          reject(error)
      }
  })
}

router.get('/supply', async function (req, res) {
    
  const queryData = await client.query({
    fetchPolicy: 'no-cache',
    query: gql`
    {
        dycos(where: { address: "0x1d3a8d49cf9e4120766c10087e50525bce08218a" }) {
          id
          address
          token
          distributionDelays
          distributionPercents
          releasesTimestamps   
          transferredTokens
          burnedTokens
        }
      }
    `,
})   
const burns = queryData.data.dycos[0].burnedTokens
const totalSupply = 312000000 
const returnValue = Math.round(totalSupply - burns)
    
  const total = await Totals.findOne({ item: 1 });
  res.json({
    circulating: total.circulating_supply,
    total: returnValue
  });
});    

module.exports = router;