giveth-bridge/lib/GivethBridge.js

Mainnet -> sidechain Giveth Bridge.

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _winston = require('winston');

var _winston2 = _interopRequireDefault(_winston);

var _contracts = require('./contracts');

var _givethLiquidpledging = require('giveth-liquidpledging');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var _class = function () {
    function _class(homeWeb3, foreignWeb3, address, foreignAddress) {
        _classCallCheck(this, _class);

        this.web3 = homeWeb3;
        this.bridge = new _contracts.GivethBridge(homeWeb3, address);
        this.foreignBridge = new _contracts.ForeignGivethBridge(foreignWeb3, foreignAddress);
        this.lp = new _givethLiquidpledging.LiquidPledging(foreignWeb3).$contract;
    }

    _createClass(_class, [{
        key: 'getRelayTransactions',
        value: function getRelayTransactions(fromBlock, toBlock) {
            var _this = this;

            if (toBlock < fromBlock) {
                _winston2.default.debug('GivethBridge -> toBlock: ' + toBlock + ' < fromBlock: ' + fromBlock + ' ... ignoring fetch getRelayTransactions request');
                return Promise.resolve([]);
            }
            return this.bridge.$contract.getPastEvents('allEvents', { fromBlock: fromBlock, toBlock: toBlock }).then(function (events) {
                return events.map(function (e) {
                    return _this.eventToTx(e);
                });
            }).then(function (promises) {
                return Promise.all(promises);
            }).then(function (results) {
                return results.filter(function (r) {
                    return r !== undefined;
                });
            });
        }
    }, {
        key: 'getToken',
        value: function getToken(mainToken) {
            return this.foreignBridge.tokenMapping(mainToken);
        }
    }, {
        key: 'eventToTx',
        value: function eventToTx(event) {
            var _this2 = this;

            _winston2.default.info('handling GivethBridge event: ', event);

            switch (event.event) {
                case 'Donate':
                    {
                        var _event$returnValues = event.returnValues,
                            giverId = _event$returnValues.giverId,
                            receiverId = _event$returnValues.receiverId,
                            token = _event$returnValues.token,
                            amount = _event$returnValues.amount;

                        return Promise.all([this.web3.eth.getTransaction(event.transactionHash), this.getToken(token)]).then(function (_ref) {
                            var _ref2 = _slicedToArray(_ref, 2),
                                tx = _ref2[0],
                                sideToken = _ref2[1];

                            if (!tx) throw new Error('Failed to fetch transaction ' + event.transactionHash);
                            return {
                                homeTx: event.transactionHash,
                                giverId: giverId,
                                receiverId: receiverId,
                                mainToken: token,
                                sideToken: sideToken,
                                amount: amount,
                                sender: tx.from,
                                data: _this2.lp.methods.donate(giverId, receiverId, sideToken, amount).encodeABI()
                            };
                        });
                    }
                case 'DonateAndCreateGiver':
                    {
                        var _event$returnValues2 = event.returnValues,
                            giver = _event$returnValues2.giver,
                            _receiverId = _event$returnValues2.receiverId,
                            _token = _event$returnValues2.token,
                            _amount = _event$returnValues2.amount;

                        return Promise.all([this.web3.eth.getTransaction(event.transactionHash), this.getToken(_token)]).then(function (_ref3) {
                            var _ref4 = _slicedToArray(_ref3, 2),
                                tx = _ref4[0],
                                sideToken = _ref4[1];

                            if (!tx) throw new Error('Failed to fetch transaction ' + event.transactionHash);
                            return {
                                homeTx: event.transactionHash,
                                giver: giver,
                                receiverId: _receiverId,
                                mainToken: _token,
                                sideToken: sideToken,
                                amount: _amount,
                                sender: tx.from,
                                data: _this2.lp.methods.addGiverAndDonate(_receiverId, giver, sideToken, _amount).encodeABI()
                            };
                        });
                    }
                default:
                    return Promise.resolve(undefined);
            }
        }
    }]);

    return _class;
}();

exports.default = _class;