@raiden_network/raiden-cli/build/routes/testing.js

Raiden Light Client standalone app with a REST API via HTTP

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeTestingRouter = void 0;
const ethers_1 = require("ethers");
const express_1 = require("express");
const validation_1 = require("../utils/validation");
const connections_1 = require("./connections");
const { formatUnits } = ethers_1.utils;
async function mintTokens(request, response, next) {
    try {
        const transactionHash = await this.raiden.mint(request.params.tokenAddress, request.body.value, { to: request.body.to });
        response.json({ transaction_hash: transactionHash });
    }
    catch (error) {
        if ((0, validation_1.isInvalidParameterError)(error))
            response.status(400).send(error.message);
        else
            next(error);
    }
}
async function getOnchainTokenBalance(request, response, next) {
    try {
        const [balance, info] = await Promise.all([
            this.raiden.getTokenBalance(request.params.tokenAddress, request.body.address),
            this.raiden.getTokenInfo(request.params.tokenAddress),
        ]);
        response.json({
            balance: balance.toString(),
            balance_txt: formatUnits(balance, info.decimals),
        });
    }
    catch (error) {
        if ((0, validation_1.isInvalidParameterError)(error))
            response.status(400).send(error.message);
        else
            next(error);
    }
}
async function transferOnchainTokens(request, response, next) {
    try {
        const transactionHash = await this.raiden.transferOnchainTokens(request.params.tokenAddress, request.body.to, request.body.value);
        response.json({ transaction_hash: transactionHash });
    }
    catch (error) {
        if ((0, validation_1.isInvalidParameterError)(error))
            response.status(400).send(error.message);
        else
            next(error);
    }
}
async function getOnchainBalance(request, response, next) {
    try {
        const balance = await this.raiden.getBalance(request.body.address);
        response.json({ balance: balance.toString(), balance_txt: formatUnits(balance, 'ether') });
    }
    catch (error) {
        if ((0, validation_1.isInvalidParameterError)(error))
            response.status(400).send(error.message);
        else
            next(error);
    }
}
async function transferOnchainBalance(request, response, next) {
    try {
        const transactionHash = await this.raiden.transferOnchainBalance(request.body.to, request.body.value);
        response.json({ transaction_hash: transactionHash });
    }
    catch (error) {
        if ((0, validation_1.isInvalidParameterError)(error))
            response.status(400).send(error.message);
        else
            next(error);
    }
}
async function exitNetwork(request, response, next) {
    try {
        const result = {
            closeTxs: [],
            settleTxs: [],
            tokensTransferTxs: [],
        };
        const closeAndSettleAllChannelsPromise = connections_1.closeAndSettleAll.call(this.raiden);
        const withdrawUdcPromise = (async () => {
            try {
                result.udcWithdrawPlanTx = await this.raiden.planUDCWithdraw();
                result.udcWithdrawTx = await this.raiden.withdrawFromUDC();
            }
            catch (e) { } // maybe no UDC deposit (remaining)
        })();
        // wait both tasks
        const [closeAndSettleTxs] = await Promise.all([
            closeAndSettleAllChannelsPromise,
            withdrawUdcPromise,
        ]);
        result.closeTxs = closeAndSettleTxs.closeTxs;
        result.settleTxs = closeAndSettleTxs.settleTxs;
        const tokens = new Set(await this.raiden.getTokenList());
        tokens.add(await this.raiden.userDepositTokenAddress());
        // if a beneficiary was provided in body
        if (request.body.beneficiary) {
            // withdraw all tokens in parallel
            await Promise.all([...tokens].map(async (token) => {
                if ((await this.raiden.getTokenBalance(token)).isZero())
                    return;
                result.tokensTransferTxs.push(await this.raiden.transferOnchainTokens(token, request.body.beneficiary));
            }));
            // transfer all ether
            if ((await this.raiden.getBalance()).gt(0)) {
                result.etherTransferTx = await this.raiden.transferOnchainBalance(request.body.beneficiary);
            }
        }
        response.json(result);
    }
    catch (error) {
        if ((0, validation_1.isInvalidParameterError)(error))
            response.status(400).send(error.message);
        else
            next(error);
    }
}
/**
 * @param this - Cli object
 * @returns Router instance
 */
function makeTestingRouter() {
    const router = (0, express_1.Router)();
    router.post('/tokens/:tokenAddress/mint', validation_1.validateAddressParameter.bind('tokenAddress'), mintTokens.bind(this));
    router.get('/tokens/:tokenAddress', validation_1.validateAddressParameter.bind('tokenAddress'), getOnchainTokenBalance.bind(this));
    router.post('/tokens/:tokenAddress/transfer', validation_1.validateAddressParameter.bind('tokenAddress'), transferOnchainTokens.bind(this));
    router.get('/balance', getOnchainBalance.bind(this));
    router.post('/balance', transferOnchainBalance.bind(this));
    /** Close/settle all channels, withdraw from UDC and optionally transfer tokens and ETH */
    router.post('/exit', exitNetwork.bind(this));
    return router;
}
exports.makeTestingRouter = makeTestingRouter;