@ledgerhq/coin-tron/lib/test/cli.js

Ledger Tron Coin integration

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = makeCliTools;
const account_1 = require("@ledgerhq/ledger-wallet-framework/account");
const invariant_1 = __importDefault(require("invariant"));
const flatMap_1 = __importDefault(require("lodash/flatMap"));
const zipWith_1 = __importDefault(require("lodash/zipWith"));
const rxjs_1 = require("rxjs");
const operators_1 = require("rxjs/operators");
const network_1 = require("../network");
const options = [
    {
        name: "token",
        alias: "t",
        type: String,
        desc: "use an token account children of the account",
    },
    {
        name: "mode",
        type: String,
        desc: "mode of transaction: send, freeze, unfreeze, withdrawExpireUnfreeze, unDelegateResource, legacyUnfreeze",
    },
    {
        name: "duration",
        type: String,
        desc: "duration in day",
    },
    {
        name: "resource",
        type: String,
        desc: "reward ENERGY or BANDWIDTH",
    },
    {
        name: "tronVoteName",
        type: String,
        multiple: true,
        desc: "name of the super representative voting",
    },
    {
        name: "tronVoteAddress",
        type: String,
        multiple: true,
        desc: "address of the super representative voting",
    },
    {
        name: "tronVoteCount",
        type: String,
        multiple: true,
        desc: "number of votes for the vote address",
    },
];
function inferAccounts(account, opts) {
    (0, invariant_1.default)(account.currency.family === "tron", "tron family");
    if (!opts.token) {
        const accounts = [account];
        return accounts;
    }
    return opts.token.map((token) => {
        const subAccounts = account.subAccounts || [];
        if (token) {
            const subAccount = subAccounts.find(t => {
                const currency = (0, account_1.getAccountCurrency)(t);
                return (token.toLowerCase() === currency.ticker.toLowerCase() ||
                    token.toLowerCase() === currency.id);
            });
            if (!subAccount) {
                throw new Error("token account '" +
                    token +
                    "' not found. Available: " +
                    subAccounts.map(t => (0, account_1.getAccountCurrency)(t).ticker).join(", "));
            }
            return subAccount;
        }
    });
}
function inferTransactions(transactions, opts) {
    const mode = opts.mode || "send";
    (0, invariant_1.default)([
        "send",
        "freeze",
        "unfreeze",
        "vote",
        "claimReward",
        "withdrawExpireUnfreeze",
        "unDelegateResource",
        "legacyUnfreeze",
    ].includes(mode), `Unexpected mode: ${mode}`);
    const resource = opts.resource ? opts.resource.toUpperCase() : undefined;
    if (resource) {
        (0, invariant_1.default)(["BANDWIDTH", "ENERGY"].includes(resource), `Unexpected resource: ${resource}`);
    }
    const voteNames = opts["tronVoteName"] || [];
    const voteAddresses = opts["tronVoteAddress"] || [];
    const voteCounts = (opts["tronVoteCount"] || []).map((value) => {
        (0, invariant_1.default)(Number.isInteger(Number(value)), `Invalid integer: ${value}`);
        return parseInt(value);
    });
    const votes = (0, zipWith_1.default)(voteNames, voteAddresses, voteCounts, (n, a, c) => ({
        name: n,
        address: a,
        voteCount: c,
    }));
    return (0, flatMap_1.default)(transactions, ({ transaction, account }) => {
        (0, invariant_1.default)(transaction.family === "tron", "tron family");
        if (account.type === "Account") {
            (0, invariant_1.default)(account.tronResources, "unactivated account");
        }
        if (account.type === "TokenAccount") {
            const isDelisted = account.token.delisted === true;
            (0, invariant_1.default)(!isDelisted, "token is delisted");
        }
        return {
            ...transaction,
            family: "tron",
            subAccountId: account.type === "TokenAccount" ? account.id : null,
            mode,
            resource,
            votes,
        };
    });
}
const formatOptStr = (str) => str || "";
const superRepresentativesFormatters = {
    json: (srData) => JSON.stringify(srData),
    default: (srData) => {
        const headerList = "address url voteCount isJobs";
        const strList = srData.list.map(sr => `${sr.address} ${formatOptStr(sr.url)} ${sr.voteCount} ${sr.isJobs}`);
        const metaData = [
            `nextVotingDate: ${srData.nextVotingDate}`,
            `totalVotes: ${srData.totalVotes}`,
        ];
        return [headerList].concat(strList).concat(metaData).join("\n");
    },
};
const tronSuperRepresentative = {
    args: [
        {
            name: "max",
            desc: "max number of super representatives to return",
            type: Number,
        },
        {
            name: "format",
            desc: Object.keys(superRepresentativesFormatters).join(" | "),
            type: String,
        },
    ],
    job: ({ max, format, }) => (0, rxjs_1.from)((0, network_1.getTronSuperRepresentativeData)(max)).pipe((0, operators_1.map)((srData) => {
        const f = format
            ? superRepresentativesFormatters[format]
            : superRepresentativesFormatters.default;
        return f(srData);
    })),
};
function makeCliTools() {
    return {
        options,
        inferAccounts,
        inferTransactions,
        commands: {
            tronSuperRepresentative,
        },
    };
}
//# sourceMappingURL=cli.js.map