autobounty/bot/index.js

const winston = require('winston')

const ethers = require('ethers')
const Wallet = ethers.Wallet
const Contract = ethers.Contract
const providers = ethers.providers
const utils = ethers.utils

const prices = require('./prices')
const config = require('../config')
const github = require('./github')

const contractAddressString = 'Contract address:'


const logger = winston.createLogger({
    level: 'info',
    format: winston.format.json(),
    transports: [
        new winston.transports.File({ filename: './log/error.log', level: 'error' }),
        new winston.transports.File({ filename: './log/info.log', level: 'info' }),
        // new winston.transports.File({ filename: './log/combined.log' })
    ]
})


const needsFunding = function (req) {
    if (req.body.action !== 'edited' || !req.body.hasOwnProperty('comment')) {
        return false
    } else if (req.body.comment.user.login !== config.githubUsername) {
        return false
    } else if (!hasAddress(req)) {
        return false
    }
    return true
}

const hasAddress = function (req) {
    const commentBody = req.body.comment.body
    if (commentBody.search(contractAddressString) === -1) {
        return false
    } else {
        return true
    }
}

const getAddress = function (req) {
    const commentBody = req.body.comment.body
    const index = commentBody.search(contractAddressString) + 19
    return commentBody.substring(index, index + 42)
}

const getLabel = function (req) {
    return new Promise((resolve, reject) => {
        github.getLabels(req)
            .then(labels => {
                const bountyLabels = labels.filter(label => config.bountyLabels.hasOwnProperty(label.name))
                if (bountyLabels.length === 1) {
                    resolve(bountyLabels[0])
                } else {
                    reject('Error getting bounty labels')
                }
            }).catch(err => {
                reject(err)
            })
    })
}

const getAmountMock = function (req) {
    return new Promise((resolve, reject) => {
        resolve(10)
    })
}

const getAmount = function (req) {
    return new Promise((resolve, reject) => {
        const labelPromise = getLabel(req)
        const tokenPricePromise = prices.getTokenPrice(config.token)

        Promise.all([labelPromise, tokenPricePromise])
            .then(function (values) {
                let label = values[0]
                let tokenPrice = values[1]
                let amountToPayDollar = config.priceHour * config.bountyLabels[label.name]
                resolve(amountToPayDollar / tokenPrice)
            })
            .catch((err) => {
                reject(err)
            })
    })
}


// Logging functions

const logTransaction = function (tx) {
    logger.info("[OK] Succesfully funded bounty with transaction " + tx.hash)
    logger.info(" * From: " + tx.from)
    logger.info(" * To: " + tx.to)
    logger.info(" * Amount: " + tx.value)
    logger.info(" * Gas Price: " + tx.gasPrice)
    logger.info("====================================================")
}

const info = function (msg) {
    logger.info(msg)
}

const error = function (errorMessage) {
    logger.error("[ERROR] Request processing failed: " + errorMessage)
}


const sendTransaction = async function (to, amount, gasPrice) {
    var chainId = providers.Provider.chainId.ropsten
    var chainName = providers.networks.ropsten

    if (config.realTransaction) {
        chainId = providers.Provider.chainId.homestead
        chainName = providers.networks.homestead
    }

    const wallet = new Wallet(config.privateKey)
    const provider = ethers.providers.getDefaultProvider(chainName)

    wallet.provider = provider
    if (config.token === 'ETH') {
        const transaction = {
            gasLimit: config.gasLimit,
            gasPrice: gasPrice,
            to: to,
            value: amount,
            chainId: chainId
        }
    
        return await wallet.sendTransaction(transaction)
    } else {
        let hash = null

        async function getAddress() { return wallet.address }
        async function sign(transaction) { return wallet.sign(transaction) }

        async function resolveName(addressOrName) { return await provider.resolveName(addressOrName) }
        async function estimateGas(transaction) { return await provider.estimateGas(transaction) }
        async function getGasPrice() { return await provider.getGasPrice() }
        async function getTransactionCount(blockTag) { return await provider.getTransactionCount(blockTag) }
        async function sendTransaction(transaction) {
            hash = await provider.sendTransaction(transaction)
            return hash
        }
        
        const customSigner = {
            getAddress: getAddress,
            provider: {
                resolveName: resolveName,
                estimateGas: estimateGas,
                getGasPrice: getGasPrice,
                getTransactionCount: getTransactionCount,
                sendTransaction: sendTransaction
            },
            sign: sign
        }

        const tokenContract = config.tokenContracts[config.token]
        const contractAddress = tokenContract.address
        const contract = new Contract(contractAddress, tokenContract.abi, customSigner)
        const bigNumberAmount = ethers.utils.bigNumberify(amount)
        await contract.transfer(to, bigNumberAmount)

        return hash
    }
}

module.exports = {
    needsFunding: needsFunding,
    getAddress: getAddress,
    getAmount: getAmount,
    getGasPrice: prices.getGasPrice,
    sendTransaction: sendTransaction,
    info: info,
    logTransaction: logTransaction,
    error: error
}