848 lines
31 KiB
JavaScript
848 lines
31 KiB
JavaScript
const nodemailer = require('nodemailer');
|
|
const logger = require('../entity/Logger.js').logger;
|
|
const tempOutputPath = require('../entity/Logger.js').tempOutputPath;
|
|
const Key = require('selenium-webdriver').Key;
|
|
const webdriver = require('selenium-webdriver'),
|
|
chrome = require('selenium-webdriver/chrome');
|
|
const fs = require('fs-extra');
|
|
const Web3 = require('web3');
|
|
const { spawn } = require('child_process');
|
|
const Crowdsale = require('../entity/Crowdsale.js').Crowdsale;
|
|
const DutchAuction = require("../entity/DutchAuction.js").DutchAuction;
|
|
const configFile = 'config.json';
|
|
const _minted = 'minted';
|
|
const _dutch = 'dutch';
|
|
|
|
const WALLET = require('./constants.js').WALLET;
|
|
const METAMASK = WALLET.METAMASK;
|
|
const NIFTY = WALLET.NIFTY;
|
|
const TIME_FORMAT = require('./constants.js').TIME_FORMAT;
|
|
|
|
const MetaMask = require('../pages/MetaMask.js').MetaMask;
|
|
const Nifty = require('../pages/Nifty.js').Nifty;
|
|
|
|
class Utils {
|
|
static async delay(ms) {
|
|
try {
|
|
await new Promise(resolve => setTimeout(resolve, ms))
|
|
return true
|
|
}
|
|
catch ( err ) {
|
|
logger.info(err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static async getWalletInstance(driver) {
|
|
logger.info("Utils: getWallet");
|
|
try {
|
|
switch ( await Utils.getWalletType() ) {
|
|
case METAMASK: {
|
|
return new MetaMask(driver);
|
|
break;
|
|
}
|
|
case NIFTY: {
|
|
return new Nifty(driver);
|
|
break;
|
|
}
|
|
default: {
|
|
return new Nifty(driver);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch ( err ) {
|
|
logger.info(err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static async startBrowserWithWallet() {
|
|
logger.info("Utils: startBrowserWithWallet");
|
|
try {
|
|
let source;
|
|
switch ( await Utils.getWalletType() ) {
|
|
case METAMASK: {
|
|
source = './public/MetaMask_4_8_0_0.crx';
|
|
break;
|
|
}
|
|
case NIFTY: {
|
|
source = './public/Nifty-Wallet_v4.8.2.crx';
|
|
break;
|
|
}
|
|
default: {
|
|
source = './public/Nifty-Wallet_v4.8.2.crx';
|
|
break;
|
|
}
|
|
}
|
|
let options = new chrome.Options();
|
|
await options.addExtensions(source);
|
|
await options.addArguments('disable-popup-blocking');
|
|
let driver = await new webdriver.Builder().withCapabilities(options.toCapabilities()).build();
|
|
await driver.sleep(5000);
|
|
if ( await Utils.getWalletType() ) await Utils.openNewTab(driver);
|
|
return driver;
|
|
}
|
|
catch ( err ) {
|
|
logger.info(err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static async openNewTab(driver) {
|
|
logger.info("Utils: openNewTab");
|
|
try {
|
|
driver.executeScript('window.open("newURL");');
|
|
return true;
|
|
}
|
|
catch ( err ) {
|
|
logger.info(err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static runGanache() {
|
|
logger.info("Utils: Run ganache-cli");
|
|
return spawn('ganache-cli');
|
|
}
|
|
|
|
static killProcess(process) {
|
|
return process.kill();
|
|
}
|
|
|
|
static async getProviderUrl(id) {
|
|
logger.info("getProvider " + id);
|
|
let provider = "";
|
|
switch ( id ) {
|
|
case 8545: {
|
|
provider = "http://localhost:8545";
|
|
break;
|
|
}
|
|
default: {
|
|
provider = "https://sokol.poa.network";
|
|
break;
|
|
}
|
|
}
|
|
return provider;
|
|
}
|
|
|
|
static async receiveEth(user, amount) {
|
|
try {
|
|
let provider = await Utils.getProviderUrl(user.networkID);
|
|
let web3 = await new Web3(new Web3.providers.HttpProvider(provider));
|
|
let account0 = await web3.eth.getAccounts().then((accounts) => {
|
|
return accounts[3];
|
|
});
|
|
|
|
logger.info("Send " + amount + " Eth from " + account0 + " to " + user.account);
|
|
await web3.eth.sendTransaction({
|
|
from: account0,
|
|
to: user.account,
|
|
value: amount * 1e18
|
|
}).then(logger.info("Transaction done"));
|
|
|
|
return true;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("Error" + err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static getWeb3Instance(network) {
|
|
logger.info("Utils: getWeb3Instance")
|
|
let url;
|
|
switch ( network ) {
|
|
case 3: {
|
|
url = "https://ropsten.infura.io";
|
|
break;
|
|
}
|
|
case 4: {
|
|
url = "https://rinkeby.infura.io/";
|
|
break;
|
|
}
|
|
case 77: {
|
|
url = "https://sokol.poa.network";
|
|
break;
|
|
}
|
|
case 8545: {
|
|
url = "http://localhost:8545";
|
|
break;
|
|
}
|
|
default: {
|
|
url = "https://sokol.poa.network";
|
|
break;
|
|
}
|
|
}
|
|
return new Web3(new Web3.providers.HttpProvider(url));
|
|
}
|
|
|
|
static async getBalance(user) {
|
|
let web3 = Utils.getWeb3Instance(user.networkID);
|
|
return await web3.eth.getBalance(user.account.toString());
|
|
}
|
|
|
|
static sendEmail(path) {
|
|
let transport = nodemailer.createTransport({
|
|
service: 'gmail',
|
|
auth: {
|
|
user: '[email protected]',
|
|
pass: 'javascript'
|
|
}
|
|
});
|
|
|
|
let mailOptions = {
|
|
from: '[email protected]',
|
|
to: '[email protected]',
|
|
subject: 'test results ' + Utils.getDateWithAdjust(0, 'utc') + " " + Utils.getTimeWithAdjust(0, 'utc'),
|
|
text: 'test results ' + Utils.getDateWithAdjust(0, 'utc') + " " + Utils.getTimeWithAdjust(0, 'utc'),
|
|
attachments: [
|
|
{ path: "" }
|
|
]
|
|
};
|
|
mailOptions.attachments[0].path = path;
|
|
transport.sendMail(mailOptions, function (error, info) {
|
|
if ( error ) {
|
|
console.log(error);
|
|
return false;
|
|
} else {
|
|
console.log('Email sent: ' + info.response);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
|
|
static compareDates(stringDate, newDate, newTime) {
|
|
let arr = stringDate.split("T");
|
|
let aww = arr[0].split("-");
|
|
let n = newDate.split("/");
|
|
return (arr[1] === newTime) && (aww[0] === n[2]) && (aww[1] === n[1]) && (aww[2] === n[0]);
|
|
}
|
|
|
|
static async getDateFormat(driver) {
|
|
|
|
let date = await driver.executeScript("var d=new Date(1999,11,28);return d.toLocaleDateString();");
|
|
date = ("" + date).substring(0, 2);
|
|
if ( date === '28' ) {
|
|
logger.info("Date format=UTC");
|
|
return TIME_FORMAT.UTC;
|
|
}
|
|
else {
|
|
logger.info("Date format=MDY");
|
|
return TIME_FORMAT.MDY;
|
|
}
|
|
}
|
|
|
|
static convertDateToMdy(date) {
|
|
let s = date.split("/");
|
|
return "" + s[1] + "/" + s[0] + "/" + s[2];
|
|
}
|
|
|
|
static convertTimeToMdy(time) {
|
|
let array = time.split(":");
|
|
let minutes = array[1].substring(0, 2);
|
|
let hours = parseInt(array[0])
|
|
let meridiem = "pm";
|
|
|
|
if ( hours > 12 ) hours = hours - 12;
|
|
else if ( hours < 12 ) meridiem = "am";
|
|
else hours = 12;
|
|
|
|
hours = "" + hours;
|
|
if ( hours.length < 2 ) hours = "0" + hours;
|
|
if ( minutes.length < 2 ) minutes = "0" + minutes;
|
|
return "" + hours + ":" + minutes + meridiem;
|
|
}
|
|
|
|
static convertDateToUtc(date) {
|
|
let s = date.split("/");
|
|
return "" + s[1] + "/" + s[0] + "/" + s[2];
|
|
}
|
|
|
|
static async getUTCPublishFormat(date) {
|
|
logger.info('Utils:getUTCPublishFormat')
|
|
const utc = new Date(new Date(date).valueOf())
|
|
const year = utc.getUTCFullYear()
|
|
const month = (utc.getUTCMonth() + 1).toString().length > 1 ? utc.getUTCMonth() + 1 : '0' + (utc.getUTCMonth() + 1)
|
|
const dat = (utc.getUTCDate().toString().length > 1) ? utc.getUTCDate() : '0' + utc.getUTCDate()
|
|
|
|
const hours = (utc.getUTCHours().toString().length>1)?utc.getUTCHours(): '0'+utc.getUTCHours()
|
|
const minutes = (utc.getUTCMinutes().toString().length>1)?utc.getUTCMinutes(): '0'+utc.getUTCMinutes()
|
|
const utcDate = year + '-' + dat + '-' + month + ' ' + hours + ':' + minutes + ' (UTC +0000)'
|
|
logger.info(utcDate)
|
|
return utcDate
|
|
}
|
|
|
|
|
|
static getTimeWithAdjust(adj, format) {
|
|
logger.info("Utils: getTimeWithAdjust, format =" + format + " , adj= " + adj)
|
|
let date = new Date(Date.now() + adj);
|
|
let meridiem = "am";
|
|
let hours = date.getHours();
|
|
let minutes = date.getMinutes();
|
|
|
|
if ( format === TIME_FORMAT.MDY )
|
|
if ( hours > 12 ) {
|
|
hours = hours - 12;
|
|
meridiem = "pm";
|
|
}
|
|
else if ( hours === 12 ) {
|
|
meridiem = "pm";
|
|
}
|
|
if ( format === TIME_FORMAT.UTC ) meridiem = "";
|
|
|
|
hours = "" + hours;
|
|
if ( hours.length < 2 ) hours = "0" + hours;
|
|
minutes = "" + minutes;
|
|
if ( minutes.length < 2 ) minutes = "0" + minutes;
|
|
return hours + ':' + minutes + meridiem
|
|
}
|
|
|
|
static getDateWithAdjust(adj, format) {
|
|
logger.info("Utils: getDateWithAdjust, format =" + format + " , adj= " + adj)
|
|
let date = new Date(Date.now() + adj);
|
|
let day = "" + date.getDate();
|
|
if ( day.length < 2 ) day = "0" + day;
|
|
let month = "" + (date.getMonth() + 1);
|
|
if ( month.length < 2 ) month = "0" + month;
|
|
|
|
if ( format === TIME_FORMAT.MDY ) return month + "/" + day + "/" + date.getFullYear();
|
|
else return day + "/" + month + "/" + date.getFullYear();
|
|
}
|
|
|
|
static getOutputPath() {
|
|
var obj = JSON.parse(fs.readFileSync(configFile, "utf8"));
|
|
return obj.outputPath;
|
|
}
|
|
|
|
static getWalletType() {
|
|
var obj = JSON.parse(fs.readFileSync(configFile, "utf8"));
|
|
return obj.wallet;
|
|
|
|
}
|
|
|
|
static getDate() {
|
|
var d = new Date();
|
|
var date = "_" + (d.getMonth() + 1) + "_" + d.getDate() + "_"
|
|
+ d.getFullYear() + "_" + d.getHours() + "_" + d.getMinutes() + "_" + d.getSeconds();
|
|
return date;
|
|
}
|
|
|
|
static getStartURL() {
|
|
var obj = JSON.parse(fs.readFileSync(configFile, "utf8"));
|
|
return obj.startURL;
|
|
|
|
}
|
|
|
|
static async takeScreenshoot(driver, name) {
|
|
|
|
var res = await driver.takeScreenshot();
|
|
var buf = new Buffer(res, 'base64');
|
|
console.log("Take screenshot. Path " + tempOutputPath + name + '.png');
|
|
await fs.writeFileSync(tempOutputPath + name + '.png', buf);
|
|
|
|
}
|
|
|
|
static async zoom(driver, z) {
|
|
await driver.executeScript("document.body.style.zoom = '" + z + "'");
|
|
}
|
|
|
|
static async getDutchAuctionCrowdsaleInstance(fileName) {
|
|
try {
|
|
let crowdsale = new DutchAuction();
|
|
await crowdsale.parser(fileName);
|
|
return crowdsale;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("Can not create crowdsale");
|
|
logger.info(err);
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
static async getMintedCrowdsaleInstance(fileName) {
|
|
try {
|
|
let crowdsale = new Crowdsale();
|
|
await crowdsale.parser(fileName);
|
|
crowdsale.sort = _minted;
|
|
return crowdsale;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("Can not create crowdsale");
|
|
logger.info(err);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static async getDutchCrowdsaleInstance(fileName) {
|
|
try {
|
|
let crowdsale = new DutchAuction();
|
|
await crowdsale.parser(fileName);
|
|
crowdsale.sort = _dutch;
|
|
return crowdsale;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("Can not create crowdsale");
|
|
logger.info(err);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static async getPathToFileInPWD(fileName) {
|
|
return process.env.PWD + "/" + fileName;
|
|
}
|
|
|
|
static async compareBalance(balanceEthOwnerBefore, balanceEthOwnerAfter, contribution, rate, delta) {
|
|
let balanceShouldBe = balanceEthOwnerBefore / 1e18 + (contribution / rate);
|
|
logger.info("contribution / rate= " + (contribution / rate));
|
|
logger.info("rate= " + rate);
|
|
logger.info("balanceEthOwnerBefore= " + balanceEthOwnerBefore / 1e18);
|
|
logger.info("contribution= " + contribution);
|
|
logger.info("balanceShouldBe= " + balanceShouldBe);
|
|
logger.info("balanceEthOwnerAfter= " + balanceEthOwnerAfter / 1e18);
|
|
if ( delta === undefined ) delta = 0.01;
|
|
logger.info("delta= " + delta);
|
|
return (Math.abs(balanceShouldBe - balanceEthOwnerAfter / 1e18) < delta);
|
|
}
|
|
|
|
static async getFromEnvMintedIDXAddress() {
|
|
logger.info("Utils:getEnvAddressMintedInitCrowdsale");
|
|
require('dotenv').config();
|
|
return Object.values(JSON.parse(process.env.REACT_APP_MINTED_CAPPED_IDX_ADDRESS))[0];
|
|
}
|
|
|
|
static async getFromEnvDutchIDXAddress() {
|
|
logger.info("Utils:getEnvAddressDutchInitCrowdsale");
|
|
require('dotenv').config();
|
|
return Object.values(JSON.parse(process.env.REACT_APP_DUTCH_IDX_ADDRESS))[0];
|
|
}
|
|
|
|
static async getFromEnvAbstractStorageAddress() {
|
|
logger.info("Utils:getEnvAddressRegistryStorage");
|
|
require('dotenv').config();
|
|
return Object.values(JSON.parse(process.env.REACT_APP_ABSTRACT_STORAGE_ADDRESS))[0];
|
|
}
|
|
|
|
static async getFromEnvNetworkId() {
|
|
logger.info("Utils:getEnvNetworkId");
|
|
require('dotenv').config();
|
|
return Object.keys(JSON.parse(process.env.REACT_APP_REGISTRY_STORAGE_ADDRESS))[0];
|
|
}
|
|
|
|
static async getContractAddressIdx(crowdsale) {
|
|
logger.info("Utils:getContractAddressIdx");
|
|
switch ( crowdsale.sort ) {
|
|
case 'minted':
|
|
return Utils.getFromEnvMintedIDXAddress();
|
|
break;
|
|
case 'dutch':
|
|
return Utils.getFromEnvDutchIDXAddress();
|
|
break;
|
|
default:
|
|
return Utils.getFromEnvMintedIDXAddress();
|
|
}
|
|
|
|
}
|
|
|
|
static async getContractSourceCode(crowdsale) {
|
|
logger.info("Utils:getContractSourceCode");
|
|
let path = '../../public/contracts/';
|
|
switch ( crowdsale.sort ) {
|
|
case 'minted':
|
|
path = path + 'MintedCappedProxy.sol';
|
|
break;
|
|
case 'dutch':
|
|
path = path + 'DutchProxy.sol';
|
|
break;
|
|
default:
|
|
path = path + 'MintedCappedProxy.sol'
|
|
}
|
|
|
|
return await fs.readFileSync(path).toString()
|
|
}
|
|
|
|
static async getContractABIInitCrowdsale(crowdsale) {
|
|
logger.info("Utils:getContractABIInitCrowdsale");
|
|
let path = './contracts/';
|
|
switch ( crowdsale.sort ) {
|
|
case 'minted':
|
|
path = path + 'MintedInitCrowdsale.abi';
|
|
break;
|
|
case 'dutch':
|
|
path = path + 'DutchInitCrowdsale.abi';
|
|
break;
|
|
default:
|
|
path = path + 'MintedInitCrowdsale.abi'
|
|
}
|
|
|
|
return await JSON.parse(fs.readFileSync(path).toString());
|
|
}
|
|
|
|
static async copyEnvFromWizard() {
|
|
logger.info("Utils:copyEnvFromWizard")
|
|
try {
|
|
fs.copySync('../../.env', './.env', { overwrite: true });
|
|
return true;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("! Can't find .env file in wizard's directory !");
|
|
logger.info(err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static async copyEnvToWizard() {
|
|
try {
|
|
fs.copySync('./.env', '../../.env', { overwrite: true });
|
|
return true;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("! Can't find .env file in e2e directory !");
|
|
logger.info(err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static async sleep(ms) {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
|
|
static async takeFunctionRateTime(crowdsale) {
|
|
try {
|
|
const abi = await Utils.getContractABIInitCrowdsale(crowdsale);
|
|
let status;
|
|
await fs.ensureDirSync("./time_rate_logs/");
|
|
let file = "./time_rate_logs/time_rate" + Date.now() + ".json";
|
|
let fileLog = "./time_rate_logs/time_rate" + Date.now() + ".log";
|
|
|
|
await fs.writeFileSync(fileLog, "startTime " + crowdsale.tiers[0].startTime + "\n");
|
|
await fs.appendFileSync(fileLog, "endTime " + crowdsale.tiers[0].endTime + "\n");
|
|
await fs.appendFileSync(fileLog, "timestamp = " + Date.now() + "\n");
|
|
await fs.appendFileSync(fileLog, "execID = " + crowdsale.executionID + "\n");
|
|
await fs.appendFileSync(fileLog, "minRate = " + crowdsale.tiers[0].minRate + "\n");
|
|
await fs.appendFileSync(fileLog, "maxRate = " + crowdsale.tiers[0].maxRate + "\n");
|
|
|
|
let object = { time: "", rate: "" };
|
|
let array = [];
|
|
let arrayLog = [];
|
|
let counter = 0;
|
|
|
|
do {
|
|
status = await Utils.getCrowdsaleStatusRopsten(crowdsale, abi);
|
|
await Utils.sleep(1000);
|
|
object.time = (counter++).toString();
|
|
object.rate = status.current_rate;
|
|
logger.info("time: " + object.time + " ,rate: " + object.rate);
|
|
array.push({
|
|
time: object.time,
|
|
rate: object.rate
|
|
});
|
|
arrayLog.push(object.rate + "\n");
|
|
}
|
|
while ( (parseInt(status.time_remaining) !== 0) );
|
|
|
|
await fs.writeJsonSync(file, array);
|
|
await fs.appendFileSync(fileLog, arrayLog);
|
|
return file;
|
|
|
|
}
|
|
catch ( err ) {
|
|
console.log("Can not takeFunctionRateTime " + err);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static async getDutchCrowdsaleStartTime(crowdsale) {
|
|
logger.info("getDutchCrowdsaleStartTime");
|
|
if ( crowdsale.sort === _minted ) return false;
|
|
let web3 = Utils.getWeb3Instance(crowdsale.networkID);
|
|
const abi = await Utils.getContractABIInitCrowdsale(crowdsale);
|
|
let myContract = new web3.eth.Contract(abi, await Utils.getFromEnvDutchIDXAddress());
|
|
let result = await myContract.methods.getCrowdsaleStartAndEndTimes(await Utils.getFromEnvAbstractStorageAddress(), crowdsale.executionID).call();
|
|
return result.start_time;
|
|
}
|
|
|
|
static async getDutchCrowdsaleEndTime(crowdsale) {
|
|
logger.info("getDutchCrowdsaleEndTime");
|
|
if ( crowdsale.sort === _minted ) return false;
|
|
let web3 = Utils.getWeb3Instance(crowdsale.networkID);
|
|
const abi = await Utils.getContractABIInitCrowdsale(crowdsale);
|
|
let myContract = new web3.eth.Contract(abi, await Utils.getFromEnvDutchIDXAddress());
|
|
let result = await myContract.methods.getCrowdsaleStartAndEndTimes(await Utils.getFromEnvAbstractStorageAddress(), crowdsale.executionID).call();
|
|
return result.end_time;
|
|
}
|
|
|
|
static async getTokensSold(crowdsale) {
|
|
logger.info("getTokenSold");
|
|
|
|
let web3 = Utils.getWeb3Instance(crowdsale.networkID);
|
|
const abi = await Utils.getContractABIInitCrowdsale(crowdsale);
|
|
let idx;
|
|
if ( crowdsale.sort === _minted ) idx = await Utils.getFromEnvMintedIDXAddress();
|
|
else idx = await Utils.getFromEnvDutchIDXAddress();
|
|
let myContract = new web3.eth.Contract(abi, idx);
|
|
let result = await myContract.methods.getTokensSold(await Utils.getFromEnvAbstractStorageAddress(), crowdsale.executionID).call();
|
|
return result;
|
|
}
|
|
|
|
static async getCrowdsaleStatusRopsten(crowdsale, abi) {
|
|
//console.log("getCrowdsaleStatusRopsten");
|
|
try {
|
|
let networkIDRopsten = 3;
|
|
const web3 = await Utils.getWeb3Instance(networkIDRopsten);
|
|
let REACT_APP_REGISTRY_STORAGE_ADDRESS = "0x9996020c8864964688411b3d90ac27eb5b0937c7";
|
|
let REACT_APP_DUTCH_CROWDSALE_INIT_CROWDSALE_ADDRESS = "0xdcD30b8417062AbDFAd1db173D66bd6e0D31929E";
|
|
let myContract = new web3.eth.Contract(abi, REACT_APP_DUTCH_CROWDSALE_INIT_CROWDSALE_ADDRESS);
|
|
let status = await myContract.methods.getCrowdsaleStatus(REACT_APP_REGISTRY_STORAGE_ADDRESS, crowdsale.executionID).call();
|
|
console.log("status = " + status);
|
|
return status;
|
|
}
|
|
catch ( err ) {
|
|
console.log("Can not get status. " + err);
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
static async getMintedCrowdsaleStartTime(crowdsale) {
|
|
logger.info("getMintedCrowdsaleStartTime");
|
|
if ( crowdsale.sort === _dutch ) return false;
|
|
let web3 = Utils.getWeb3Instance(crowdsale.networkID);
|
|
const abi = await Utils.getContractABIInitCrowdsale(crowdsale);
|
|
let myContract = new web3.eth.Contract(abi, await Utils.getFromEnvMintedIDXAddress());
|
|
let result = await myContract.methods.getCrowdsaleStartAndEndTimes(await Utils.getFromEnvAbstractStorageAddress(), crowdsale.executionID).call();
|
|
return result.start_time;
|
|
}
|
|
|
|
static async getTiersEndTimeMintedCrowdsale(crowdsale, tierNumber) {
|
|
logger.info("Utils: getTiersEndTimeMintedCrowdsale");
|
|
if ( crowdsale.sort === _dutch ) return false;
|
|
let web3 = Utils.getWeb3Instance(crowdsale.networkID);
|
|
const abi = await Utils.getContractABIInitCrowdsale(crowdsale);
|
|
let myContract = new web3.eth.Contract(abi, await Utils.getFromEnvMintedIDXAddress());
|
|
let result = await myContract.methods.getTierStartAndEndDates(await Utils.getFromEnvAbstractStorageAddress(), crowdsale.executionID, tierNumber - 1).call();
|
|
return result.tier_end;
|
|
}
|
|
|
|
static async getTierWhitelistMintedCrowdsale(crowdsale, tierNumber) {
|
|
logger.info("Utils: getTierWhitelistMinted");
|
|
if ( crowdsale.sort === _dutch ) return false;
|
|
let web3 = Utils.getWeb3Instance(crowdsale.networkID);
|
|
const abi = await Utils.getContractABIInitCrowdsale(crowdsale);
|
|
let myContract = new web3.eth.Contract(abi, await Utils.getFromEnvMintedIDXAddress());
|
|
let result = await myContract.methods.getTierWhitelist(await Utils.getFromEnvAbstractStorageAddress(), crowdsale.executionID, tierNumber - 1).call();
|
|
return result.num_whitelisted;
|
|
}
|
|
|
|
static async getCrowdsaleWhitelistDutchCrowdsale(crowdsale) {
|
|
logger.info("Utils: getTierWhitelistMinted");
|
|
if ( crowdsale.sort === _minted ) return false;
|
|
let web3 = Utils.getWeb3Instance(crowdsale.networkID);
|
|
const abi = await Utils.getContractABIInitCrowdsale(crowdsale);
|
|
let myContract = new web3.eth.Contract(abi, await Utils.getFromEnvDutchIDXAddress());
|
|
let result = await myContract.methods.getCrowdsaleWhitelist(await Utils.getFromEnvAbstractStorageAddress(), crowdsale.executionID).call();
|
|
return result.num_whitelisted;
|
|
}
|
|
|
|
static async deployContract(web3, abi, bin, from, parameters) {
|
|
console.log("Utils: deployContract")
|
|
console.log("from address= " + from)
|
|
const contract = new web3.eth.Contract(abi, { from });
|
|
const gas = 8900000;
|
|
const gasPrice = '10000000000';
|
|
console.log("parametersabstractStorage: " + parameters[0]);
|
|
console.log("parametersmintedIdx: " + parameters[1]);
|
|
console.log("parametersdutchIdx: " + parameters[2]);
|
|
return contract
|
|
.deploy(
|
|
{
|
|
data: bin,
|
|
arguments: parameters
|
|
}
|
|
)
|
|
.send({
|
|
from,
|
|
gas,
|
|
gasPrice
|
|
})
|
|
}
|
|
|
|
static async deployTWProxiesRegistry(network, registryPath) {
|
|
logger.info("Utils:deployTWProxiesRegistry ");
|
|
|
|
//const web3 = await new Web3(new Web3.providers.HttpProvider('http://localhost:8545'));
|
|
const web3 = await Utils.getWeb3Instance(network);
|
|
const registryAbi = await JSON.parse(fs.readFileSync(`${registryPath}.abi`).toString());
|
|
let registryBin = await fs.readFileSync(`${registryPath}.bin`).toString();
|
|
if ( registryBin.slice(0, 2) !== '0x' && registryBin.slice(0, 2) !== '0X' ) {
|
|
registryBin = '0x' + registryBin;
|
|
}
|
|
|
|
let abstractStorage = await Utils.getFromEnvAbstractStorageAddress();
|
|
let mintedIdx = await Utils.getFromEnvMintedIDXAddress();
|
|
let dutchIdx = await Utils.getFromEnvDutchIDXAddress();
|
|
|
|
let account = await web3.eth.getAccounts().then((accounts) => {
|
|
return accounts[0]
|
|
});
|
|
let contract = await Utils.deployContract(web3, registryAbi, registryBin, account, [abstractStorage, mintedIdx, dutchIdx]);
|
|
|
|
const networkID = await web3.eth.net.getId();
|
|
const registryAddress = contract._address;
|
|
let envContent = `REACT_APP_TW_PROXIES_REGISTRY_ADDRESS='{"${networkID}":"${registryAddress}"}'`;
|
|
console.log(envContent);
|
|
console.log("abstractStorage: " + abstractStorage);
|
|
console.log("mintedIdx: " + mintedIdx);
|
|
console.log("dutchIdx: " + dutchIdx);
|
|
|
|
if ( await !fs.existsSync("./.env") ) await fs.writeFileSync("./.env");
|
|
await fs.appendFileSync("./.env", envContent);
|
|
}
|
|
|
|
static async deployTWProxiesRegistryToRopsten(network, registryPath) {
|
|
logger.info("Utils:deployTWProxiesRegistry ");
|
|
|
|
//const web3 = await new Web3(new Web3.providers.HttpProvider('http://localhost:8545'));
|
|
const web3 = await Utils.getWeb3Instance(3);
|
|
const registryAbi = await JSON.parse(fs.readFileSync(`${registryPath}.abi`).toString());
|
|
let registryBin = await fs.readFileSync(`${registryPath}.bin`).toString();
|
|
if ( registryBin.slice(0, 2) !== '0x' && registryBin.slice(0, 2) !== '0X' ) {
|
|
registryBin = '0x' + registryBin;
|
|
}
|
|
|
|
let abstractStorage = await Utils.getFromEnvAbstractStorageAddress();
|
|
let mintedIdx = await Utils.getFromEnvMintedIDXAddress();
|
|
let dutchIdx = await Utils.getFromEnvDutchIDXAddress();
|
|
|
|
let privateKey = "0xba98116a7d4b98f22f113c59448b9cc69f916d75f35d51f088b64b483fd0b8ca";
|
|
let account = web3.eth.accounts.privateKeyToAccount(privateKey);
|
|
console.log(account.address);
|
|
let bal = await web3.eth.getBalance(account.address.toString())
|
|
console.log("bal= " + bal / 1e18);
|
|
console.log("abstractStorage: " + abstractStorage);
|
|
console.log("mintedIdx: " + mintedIdx);
|
|
console.log("dutchIdx: " + dutchIdx);
|
|
const networkID = await web3.eth.net.getId();
|
|
console.log("networkID: " + networkID);
|
|
/*
|
|
let account = await web3.eth.getAccounts().then((accounts) => {
|
|
return accounts[0]
|
|
});*/
|
|
let contract = await Utils.deployContract(web3, registryAbi, registryBin, account.address, [abstractStorage, mintedIdx, dutchIdx]);
|
|
|
|
const registryAddress = contract._address;
|
|
let envContent = `REACT_APP_TW_PROXIES_REGISTRY_ADDRESS='{"${networkID}":"${registryAddress}"}'`;
|
|
console.log(envContent);
|
|
|
|
if ( await !fs.existsSync("./.env") ) await fs.writeFileSync("./.env");
|
|
await fs.appendFileSync("./.env", envContent);
|
|
}
|
|
|
|
//////////// PROXY /////////////////////////////////////
|
|
|
|
static async getContractABIProxy(crowdsale) {
|
|
logger.info("Utils:getContractABIProxy");
|
|
let path = './contracts/Proxies.abi';
|
|
return await JSON.parse(fs.readFileSync(path).toString());
|
|
}
|
|
|
|
static async getProxyExecID(crowdsale) {
|
|
logger.info("getProxyExecID");
|
|
try {
|
|
let web3 = Utils.getWeb3Instance(crowdsale.networkID);
|
|
const abi = await Utils.getContractABIProxy(crowdsale);
|
|
let myContract = new web3.eth.Contract(abi, crowdsale.proxyAddress.toString());
|
|
let result = await myContract.methods.app_exec_id().call();
|
|
logger.info("app_exec_id " + result);
|
|
return result;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("Can't read contract. Error: " + err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static async generateCSVReservedAddresses(amountReserved) {
|
|
logger.info("generateCSVReservedAddresses");
|
|
try {
|
|
console.log(amountReserved);
|
|
let path = "./reservedAddressesCSV";
|
|
await fs.ensureDirSync(path);
|
|
let dateNow = Date.now();
|
|
let fileName = path + "/reservedAddresses" + amountReserved + "_" + dateNow;
|
|
let fileCSV = fileName + ".csv";
|
|
let fileJSON = fileName + ".json";
|
|
let array = [];
|
|
let dimension;
|
|
let value;
|
|
let web3 = Utils.getWeb3Instance(8545);
|
|
let account;
|
|
for ( let i = 0; i < amountReserved; i++ ) {
|
|
account = web3.eth.accounts.create();
|
|
dimension = (Math.random() > 0.5) ? "percentage" : "tokens";
|
|
value = Math.random() * 1e10;
|
|
array.push({
|
|
account: account,
|
|
dimension: dimension,
|
|
value: value
|
|
});
|
|
//console.log(i+" "+account.address + "," + dimension + "," + value + "\n")
|
|
await fs.appendFileSync(fileCSV, "" + account.address + "," + dimension + "," + value + "\n");
|
|
}
|
|
|
|
await fs.writeJsonSync(fileJSON, { reservedAddresses: array });
|
|
return fileName;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("Error: " + err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static async generateCSVWhitelistedAddresses(amount) {
|
|
logger.info("generateCSVWhitelistedAddresses");
|
|
try {
|
|
console.log(amount);
|
|
let path = "./whitelistedAddressesCSV";
|
|
await fs.ensureDirSync(path);
|
|
let dateNow = Date.now();
|
|
let fileName = path + "/whitelistedAddresses" + amount + "_" + dateNow;
|
|
let fileCSV = fileName + ".csv";
|
|
let fileJSON = fileName + ".json";
|
|
let array = [];
|
|
let max;
|
|
let min;
|
|
let web3 = Utils.getWeb3Instance(8545);
|
|
let account;
|
|
for ( let i = 0; i < amount; i++ ) {
|
|
account = web3.eth.accounts.create();
|
|
|
|
min = Math.round(Math.random() * 1e3);
|
|
max = min + Math.round(Math.random() * 1e3);
|
|
array.push({
|
|
account: account,
|
|
min: min,
|
|
max: max
|
|
});
|
|
//console.log(i+" "+account.address + "," + dimension + "," + value + "\n")
|
|
await fs.appendFileSync(fileCSV, "" + account.address + "," + min + "," + max + "\n");
|
|
}
|
|
|
|
await fs.writeJsonSync(fileJSON, { whitelistedAddresses: array });
|
|
return fileName;
|
|
}
|
|
catch ( err ) {
|
|
logger.info("Error: " + err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
module.exports = {
|
|
Utils: Utils
|
|
|
|
}
|
|
|