@ledgerhq/coin-tron 0.2.2 → 0.2.3-next.0

package/lib-es/network/index.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { hours, makeLRUCache } from "@ledgerhq/live-network/cache";
 import network from "@ledgerhq/live-network";
 import { promiseAllBatched } from "@ledgerhq/live-promise";
@@ -25,71 +16,65 @@ import { decode58Check, encode58Check, formatTrongridTrc20TxResponse, formatTron
 import { isMalformedTransactionTronAPI, isTransactionTronAPI, } from "./types";
 import { stringify } from "querystring";
 const getBaseApiUrl = () => getCoinConfig().explorer.url;
-function post(endPoint, body) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { data } = yield network({
-            method: "POST",
-            url: `${getBaseApiUrl()}${endPoint}`,
-            data: body,
-        });
-        // Ugly but trongrid send a 200 status event if there are errors
-        if ("Error" in data) {
-            log("tron-error", stringify(data.Error), {
-                endPoint,
-                body,
-            });
-            throw new Error(stringify(data.Error));
-        }
-        return data;
+async function post(endPoint, body) {
+    const { data } = await network({
+        method: "POST",
+        url: `${getBaseApiUrl()}${endPoint}`,
+        data: body,
     });
+    // Ugly but trongrid send a 200 status event if there are errors
+    if ("Error" in data) {
+        log("tron-error", stringify(data.Error), {
+            endPoint,
+            body,
+        });
+        throw new Error(stringify(data.Error));
+    }
+    return data;
 }
-function fetch(endPoint) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fetchWithBaseUrl(`${getBaseApiUrl()}${endPoint}`);
-    });
+async function fetch(endPoint) {
+    return fetchWithBaseUrl(`${getBaseApiUrl()}${endPoint}`);
 }
-function fetchWithBaseUrl(url) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { data } = yield network({ url });
-        // Ugly but trongrid send a 200 status event if there are errors
-        if ("Error" in data) {
-            log("tron-error", stringify(data.Error), {
-                url,
-            });
-            throw new Error(stringify(data.Error));
-        }
-        return data;
-    });
+async function fetchWithBaseUrl(url) {
+    const { data } = await network({ url });
+    // Ugly but trongrid send a 200 status event if there are errors
+    if ("Error" in data) {
+        log("tron-error", stringify(data.Error), {
+            url,
+        });
+        throw new Error(stringify(data.Error));
+    }
+    return data;
 }
-export const freezeTronTransaction = (account, transaction) => __awaiter(void 0, void 0, void 0, function* () {
+export const freezeTronTransaction = async (account, transaction) => {
     const txData = {
         frozen_balance: transaction.amount.toNumber(),
         resource: transaction.resource,
         owner_address: decode58Check(account.freshAddress),
     };
     const url = `/wallet/freezebalancev2`;
-    const result = yield post(url, txData);
+    const result = await post(url, txData);
     return result;
-});
-export const unfreezeTronTransaction = (account, transaction) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const unfreezeTronTransaction = async (account, transaction) => {
     const txData = {
         owner_address: decode58Check(account.freshAddress),
         resource: transaction.resource,
         unfreeze_balance: transaction.amount.toNumber(),
     };
     const url = `/wallet/unfreezebalancev2`;
-    const result = yield post(url, txData);
+    const result = await post(url, txData);
     return result;
-});
-export const withdrawExpireUnfreezeTronTransaction = (account, _transaction) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const withdrawExpireUnfreezeTronTransaction = async (account, _transaction) => {
     const txData = {
         owner_address: decode58Check(account.freshAddress),
     };
     const url = `/wallet/withdrawexpireunfreeze`;
-    const result = yield post(url, txData);
+    const result = await post(url, txData);
     return result;
-});
-export const unDelegateResourceTransaction = (account, transaction) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const unDelegateResourceTransaction = async (account, transaction) => {
     const txData = {
         balance: transaction.amount.toNumber(),
         resource: transaction.resource,
@@ -97,41 +82,39 @@ export const unDelegateResourceTransaction = (account, transaction) => __awaiter
         receiver_address: decode58Check(transaction.recipient),
     };
     const url = `/wallet/undelegateresource`;
-    const result = yield post(url, txData);
+    const result = await post(url, txData);
     return result;
-});
-export const legacyUnfreezeTronTransaction = (account, transaction) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const legacyUnfreezeTronTransaction = async (account, transaction) => {
     const txData = {
         resource: transaction.resource,
         owner_address: decode58Check(account.freshAddress),
         receiver_address: transaction.recipient ? decode58Check(transaction.recipient) : undefined,
     };
     const url = `/wallet/unfreezebalance`;
-    const result = yield post(url, txData);
+    const result = await post(url, txData);
     return result;
-});
-export function getDelegatedResource(account, transaction, resource) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const url = `/wallet/getdelegatedresourcev2`;
-        const { delegatedResource = [], } = yield post(url, {
-            fromAddress: decode58Check(account.freshAddress),
-            toAddress: decode58Check(transaction.recipient),
-        });
-        const { frozen_balance_for_bandwidth, frozen_balance_for_energy } = delegatedResource.reduce((accum, cur) => {
-            if (cur.frozen_balance_for_bandwidth) {
-                accum.frozen_balance_for_bandwidth += cur.frozen_balance_for_bandwidth;
-            }
-            if (cur.frozen_balance_for_energy) {
-                accum.frozen_balance_for_energy += cur.frozen_balance_for_energy;
-            }
-            return accum;
-        }, { frozen_balance_for_bandwidth: 0, frozen_balance_for_energy: 0 });
-        const amount = resource === "BANDWIDTH" ? frozen_balance_for_bandwidth : frozen_balance_for_energy;
-        return new BigNumber(amount);
+};
+export async function getDelegatedResource(account, transaction, resource) {
+    const url = `/wallet/getdelegatedresourcev2`;
+    const { delegatedResource = [], } = await post(url, {
+        fromAddress: decode58Check(account.freshAddress),
+        toAddress: decode58Check(transaction.recipient),
     });
+    const { frozen_balance_for_bandwidth, frozen_balance_for_energy } = delegatedResource.reduce((accum, cur) => {
+        if (cur.frozen_balance_for_bandwidth) {
+            accum.frozen_balance_for_bandwidth += cur.frozen_balance_for_bandwidth;
+        }
+        if (cur.frozen_balance_for_energy) {
+            accum.frozen_balance_for_energy += cur.frozen_balance_for_energy;
+        }
+        return accum;
+    }, { frozen_balance_for_bandwidth: 0, frozen_balance_for_energy: 0 });
+    const amount = resource === "BANDWIDTH" ? frozen_balance_for_bandwidth : frozen_balance_for_energy;
+    return new BigNumber(amount);
 }
 // Send trx or trc10/trc20 tokens
-export const createTronTransaction = (account, transaction, subAccount) => __awaiter(void 0, void 0, void 0, function* () {
+export const createTronTransaction = async (account, transaction, subAccount) => {
     const [tokenType, tokenId] = subAccount && subAccount.type === "TokenAccount"
         ? drop(subAccount.token.id.split("/"), 1)
         : [undefined, undefined];
@@ -147,7 +130,7 @@ export const createTronTransaction = (account, transaction, subAccount) => __awa
             owner_address: decode58Check(account.freshAddress),
         };
         const url = `/wallet/triggersmartcontract`;
-        const { transaction: preparedTransaction } = yield post(url, txData);
+        const { transaction: preparedTransaction } = await post(url, txData);
         return extendTronTxExpirationTimeBy10mn(preparedTransaction);
     }
     else {
@@ -159,11 +142,11 @@ export const createTronTransaction = (account, transaction, subAccount) => __awa
             asset_name: tokenId && Buffer.from(tokenId).toString("hex"),
         };
         const url = subAccount ? `/wallet/transferasset` : `/wallet/createtransaction`;
-        const preparedTransaction = yield post(url, txData);
+        const preparedTransaction = await post(url, txData);
         // for the ledger Vault we need to increase the expiration
         return extendTronTxExpirationTimeBy10mn(preparedTransaction);
     }
-});
+};
 function extendTronTxExpirationTimeBy10mn(preparedTransaction) {
     const VAULT_EXPIRATION_TIME = 600;
     const HttpProvider = TronWeb.providers.HttpProvider;
@@ -174,114 +157,102 @@ function extendTronTxExpirationTimeBy10mn(preparedTransaction) {
     //FIXME: test it and rewrite it
     return tronWeb.transactionBuilder.extendExpiration(preparedTransaction, VAULT_EXPIRATION_TIME);
 }
-export const broadcastTron = (trxTransaction) => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield post(`/wallet/broadcasttransaction`, trxTransaction);
+export const broadcastTron = async (trxTransaction) => {
+    const result = await post(`/wallet/broadcasttransaction`, trxTransaction);
     if (result.code === "TRANSACTION_EXPIRATION_ERROR") {
         throw new TronTransactionExpired();
     }
     return result;
-});
-export function fetchTronAccount(addr) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const data = yield fetch(`/v1/accounts/${addr}`);
-            return data.data;
-        }
-        catch (e) {
-            return [];
-        }
-    });
+};
+export async function fetchTronAccount(addr) {
+    try {
+        const data = await fetch(`/v1/accounts/${addr}`);
+        return data.data;
+    }
+    catch (e) {
+        return [];
+    }
 }
-export function fetchCurrentBlockHeight() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const data = yield fetch(`/wallet/getnowblock`);
-        return data.block_header.raw_data.number;
-    });
+export async function fetchCurrentBlockHeight() {
+    const data = await fetch(`/wallet/getnowblock`);
+    return data.block_header.raw_data.number;
 }
 // For the moment, fetching transaction info is the only way to get fees from a transaction
-function fetchTronTxDetail(txId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { fee, blockNumber, withdraw_amount, unfreeze_amount } = yield fetch(`/wallet/gettransactioninfobyid?value=${encodeURIComponent(txId)}`);
-        return {
-            fee,
-            blockNumber,
-            withdraw_amount,
-            unfreeze_amount,
-        };
-    });
+async function fetchTronTxDetail(txId) {
+    const { fee, blockNumber, withdraw_amount, unfreeze_amount } = await fetch(`/wallet/gettransactioninfobyid?value=${encodeURIComponent(txId)}`);
+    return {
+        fee,
+        blockNumber,
+        withdraw_amount,
+        unfreeze_amount,
+    };
 }
-function getAllTransactions(initialUrl, shouldFetchMoreTxs, getTxs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let all = [];
-        let url = initialUrl;
-        while (url && shouldFetchMoreTxs(all)) {
-            const { nextUrl, results } = yield getTxs(url);
-            url = nextUrl;
-            all = all.concat(results);
-        }
-        return all;
-    });
+async function getAllTransactions(initialUrl, shouldFetchMoreTxs, getTxs) {
+    let all = [];
+    let url = initialUrl;
+    while (url && shouldFetchMoreTxs(all)) {
+        const { nextUrl, results } = await getTxs(url);
+        url = nextUrl;
+        all = all.concat(results);
+    }
+    return all;
 }
-const getTransactions = (cacheTransactionInfoById) => (url) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const transactions = yield fetchWithBaseUrl(url);
-    const nextUrl = (_b = (_a = transactions.meta.links) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.replace(/https:\/\/api(\.[a-z]*)?.trongrid.io/, getBaseApiUrl());
-    const results = yield promiseAllBatched(3, transactions.data || [], (tx) => __awaiter(void 0, void 0, void 0, function* () {
+const getTransactions = (cacheTransactionInfoById) => async (url) => {
+    const transactions = await fetchWithBaseUrl(url);
+    const nextUrl = transactions.meta.links?.next?.replace(/https:\/\/api(\.[a-z]*)?.trongrid.io/, getBaseApiUrl());
+    const results = await promiseAllBatched(3, transactions.data || [], async (tx) => {
         if (isMalformedTransactionTronAPI(tx)) {
             return tx;
         }
         const txID = tx.txID;
-        const detail = cacheTransactionInfoById[txID] || (yield fetchTronTxDetail(txID));
+        const detail = cacheTransactionInfoById[txID] || (await fetchTronTxDetail(txID));
         cacheTransactionInfoById[txID] = detail;
-        return Object.assign(Object.assign({}, tx), { detail });
-    }));
+        return { ...tx, detail };
+    });
     return {
         results,
         nextUrl,
     };
-});
-const getTrc20 = (url) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const transactions = yield fetchWithBaseUrl(url);
+};
+const getTrc20 = async (url) => {
+    const transactions = await fetchWithBaseUrl(url);
     return {
         results: transactions.data,
-        nextUrl: (_b = (_a = transactions.meta.links) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.replace(/https:\/\/api(\.[a-z]*)?.trongrid.io/, getBaseApiUrl()),
+        nextUrl: transactions.meta.links?.next?.replace(/https:\/\/api(\.[a-z]*)?.trongrid.io/, getBaseApiUrl()),
     };
-});
-export function fetchTronAccountTxs(addr, shouldFetchMoreTxs, cacheTransactionInfoById) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const entireTxs = (yield getAllTransactions(`${getBaseApiUrl()}/v1/accounts/${addr}/transactions?limit=100`, shouldFetchMoreTxs, getTransactions(cacheTransactionInfoById)))
-            .filter((tx) => isTransactionTronAPI(tx))
-            .filter(tx => {
-            // custom smart contract tx has internal txs
-            const hasInternalTxs = tx.txID && tx.internal_transactions && tx.internal_transactions.length > 0;
-            // and also a duplicated malformed tx that we have to ignore
-            const isDuplicated = tx.tx_id;
-            const type = tx.raw_data.contract[0].type;
-            if (hasInternalTxs) {
-                // log once
-                log("tron-error", `unsupported transaction ${tx.txID}`);
-            }
-            return !isDuplicated && !hasInternalTxs && type !== "TriggerSmartContract";
-        })
-            .map(tx => formatTrongridTxResponse(tx));
-        // we need to fetch and filter trc20 transactions from another endpoint
-        const entireTrc20Txs = (yield getAllTransactions(`${getBaseApiUrl()}/v1/accounts/${addr}/transactions/trc20?get_detail=true`, shouldFetchMoreTxs, getTrc20)).map(tx => formatTrongridTrc20TxResponse(tx));
-        const txInfos = compact(entireTxs.concat(entireTrc20Txs)).sort((a, b) => b.date.getTime() - a.date.getTime());
-        return txInfos;
-    });
+};
+export async function fetchTronAccountTxs(addr, shouldFetchMoreTxs, cacheTransactionInfoById) {
+    const entireTxs = (await getAllTransactions(`${getBaseApiUrl()}/v1/accounts/${addr}/transactions?limit=100`, shouldFetchMoreTxs, getTransactions(cacheTransactionInfoById)))
+        .filter((tx) => isTransactionTronAPI(tx))
+        .filter(tx => {
+        // custom smart contract tx has internal txs
+        const hasInternalTxs = tx.txID && tx.internal_transactions && tx.internal_transactions.length > 0;
+        // and also a duplicated malformed tx that we have to ignore
+        const isDuplicated = tx.tx_id;
+        const type = tx.raw_data.contract[0].type;
+        if (hasInternalTxs) {
+            // log once
+            log("tron-error", `unsupported transaction ${tx.txID}`);
+        }
+        return !isDuplicated && !hasInternalTxs && type !== "TriggerSmartContract";
+    })
+        .map(tx => formatTrongridTxResponse(tx));
+    // we need to fetch and filter trc20 transactions from another endpoint
+    const entireTrc20Txs = (await getAllTransactions(`${getBaseApiUrl()}/v1/accounts/${addr}/transactions/trc20?get_detail=true`, shouldFetchMoreTxs, getTrc20)).map(tx => formatTrongridTrc20TxResponse(tx));
+    const txInfos = compact(entireTxs.concat(entireTrc20Txs)).sort((a, b) => b.date.getTime() - a.date.getTime());
+    return txInfos;
 }
-export const getContractUserEnergyRatioConsumption = (address) => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield fetchTronContract(address);
+export const getContractUserEnergyRatioConsumption = async (address) => {
+    const result = await fetchTronContract(address);
     if (result) {
         const { consume_user_resource_percent } = result;
         return consume_user_resource_percent;
     }
     return 0;
-});
-export const fetchTronContract = (addr) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const fetchTronContract = async (addr) => {
     try {
-        const data = yield post(`/wallet/getcontract`, {
+        const data = await post(`/wallet/getcontract`, {
             value: decode58Check(addr),
         });
         return Object.keys(data).length !== 0 ? data : undefined;
@@ -289,9 +260,9 @@ export const fetchTronContract = (addr) => __awaiter(void 0, void 0, void 0, fun
     catch (e) {
         return undefined;
     }
-});
-export const getTronAccountNetwork = (address) => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield fetch(`/wallet/getaccountresource?address=${encodeURIComponent(decode58Check(address))}`);
+};
+export const getTronAccountNetwork = async (address) => {
+    const result = await fetch(`/wallet/getaccountresource?address=${encodeURIComponent(decode58Check(address))}`);
     const { freeNetUsed = 0, freeNetLimit = 0, NetUsed = 0, NetLimit = 0, EnergyUsed = 0, EnergyLimit = 0, } = result;
     return {
         family: "tron",
@@ -302,10 +273,10 @@ export const getTronAccountNetwork = (address) => __awaiter(void 0, void 0, void
         energyUsed: new BigNumber(EnergyUsed),
         energyLimit: new BigNumber(EnergyLimit),
     };
-});
-export const validateAddress = (address) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const validateAddress = async (address) => {
     try {
-        const result = yield post(`/wallet/validateaddress`, {
+        const result = await post(`/wallet/validateaddress`, {
             address: decode58Check(address),
         });
         return result.result || false;
@@ -317,61 +288,68 @@ export const validateAddress = (address) => __awaiter(void 0, void 0, void 0, fu
         });
         return false;
     }
-});
+};
 // cache for account names (name is unchanged over time)
-const accountNamesCache = makeLRUCache((addr) => __awaiter(void 0, void 0, void 0, function* () { return getAccountName(addr); }), (addr) => addr, hours(3, 300));
+const accountNamesCache = makeLRUCache(async (addr) => getAccountName(addr), (addr) => addr, hours(3, 300));
 // cache for super representative brokerages (brokerage is unchanged over time)
-const srBrokeragesCache = makeLRUCache((addr) => __awaiter(void 0, void 0, void 0, function* () { return getBrokerage(addr); }), (addr) => addr, hours(3, 300));
-export const getAccountName = (addr) => __awaiter(void 0, void 0, void 0, function* () {
-    const tronAcc = yield fetchTronAccount(addr);
+const srBrokeragesCache = makeLRUCache(async (addr) => getBrokerage(addr), (addr) => addr, hours(3, 300));
+export const getAccountName = async (addr) => {
+    const tronAcc = await fetchTronAccount(addr);
     const acc = tronAcc[0];
     const accountName = acc && acc.account_name ? hexToAscii(acc.account_name) : undefined;
     accountNamesCache.hydrate(addr, accountName); // put it in cache
     return accountName;
-});
-export const getBrokerage = (addr) => __awaiter(void 0, void 0, void 0, function* () {
-    const { brokerage } = yield fetch(`/wallet/getBrokerage?address=${encodeURIComponent(addr)}`);
+};
+export const getBrokerage = async (addr) => {
+    const { brokerage } = await fetch(`/wallet/getBrokerage?address=${encodeURIComponent(addr)}`);
     srBrokeragesCache.hydrate(addr, brokerage); // put it in cache
     return brokerage;
-});
-const superRepresentativesCache = makeLRUCache(() => __awaiter(void 0, void 0, void 0, function* () {
-    const superRepresentatives = yield fetchSuperRepresentatives();
+};
+const superRepresentativesCache = makeLRUCache(async () => {
+    const superRepresentatives = await fetchSuperRepresentatives();
     log("tron/superRepresentatives", "loaded " + superRepresentatives.length + " super representatives");
     return superRepresentatives;
-}), () => "", hours(1, 300));
-export const getTronSuperRepresentatives = () => __awaiter(void 0, void 0, void 0, function* () {
-    return yield superRepresentativesCache();
-});
+}, () => "", hours(1, 300));
+export const getTronSuperRepresentatives = async () => {
+    return await superRepresentativesCache();
+};
 export const hydrateSuperRepresentatives = (list) => {
     log("tron/superRepresentatives", "hydrate " + list.length + " super representatives");
     superRepresentativesCache.hydrate("", list);
 };
-const fetchSuperRepresentatives = () => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield fetch(`/wallet/listwitnesses`);
+const fetchSuperRepresentatives = async () => {
+    const result = await fetch(`/wallet/listwitnesses`);
     const sorted = result.witnesses.sort((a, b) => b.voteCount - a.voteCount);
-    const superRepresentatives = yield promiseAllBatched(3, sorted, (w) => __awaiter(void 0, void 0, void 0, function* () {
+    const superRepresentatives = await promiseAllBatched(3, sorted, async (w) => {
         const encodedAddress = encode58Check(w.address);
-        const accountName = yield accountNamesCache(encodedAddress);
-        const brokerage = yield srBrokeragesCache(encodedAddress);
-        return Object.assign(Object.assign({}, w), { address: encodedAddress, name: accountName, brokerage, voteCount: w.voteCount || 0, isJobs: w.isJobs || false });
-    }));
+        const accountName = await accountNamesCache(encodedAddress);
+        const brokerage = await srBrokeragesCache(encodedAddress);
+        return {
+            ...w,
+            address: encodedAddress,
+            name: accountName,
+            brokerage,
+            voteCount: w.voteCount || 0,
+            isJobs: w.isJobs || false,
+        };
+    });
     hydrateSuperRepresentatives(superRepresentatives); // put it in cache
     return superRepresentatives;
-});
-export const getNextVotingDate = () => __awaiter(void 0, void 0, void 0, function* () {
-    const { num } = yield fetch(`/wallet/getnextmaintenancetime`);
+};
+export const getNextVotingDate = async () => {
+    const { num } = await fetch(`/wallet/getnextmaintenancetime`);
     return new Date(num);
-});
-export const getTronSuperRepresentativeData = (max) => __awaiter(void 0, void 0, void 0, function* () {
-    const list = yield getTronSuperRepresentatives();
-    const nextVotingDate = yield getNextVotingDate();
+};
+export const getTronSuperRepresentativeData = async (max) => {
+    const list = await getTronSuperRepresentatives();
+    const nextVotingDate = await getNextVotingDate();
     return {
         list: max ? take(list, max) : list,
         totalVotes: sumBy(list, "voteCount"),
         nextVotingDate,
     };
-});
-export const voteTronSuperRepresentatives = (account, transaction) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const voteTronSuperRepresentatives = async (account, transaction) => {
     const payload = {
         owner_address: decode58Check(account.freshAddress),
         votes: transaction.votes.map(v => ({
@@ -379,146 +357,143 @@ export const voteTronSuperRepresentatives = (account, transaction) => __awaiter(
             vote_count: v.voteCount,
         })),
     };
-    return yield post(`/wallet/votewitnessaccount`, payload);
-});
-export function getTronResources(acc_1, txs_1) {
-    return __awaiter(this, arguments, void 0, function* (acc, txs, cacheTransactionInfoById = {}) {
-        if (!acc) {
-            return defaultTronResources;
+    return await post(`/wallet/votewitnessaccount`, payload);
+};
+export async function getTronResources(acc, txs, cacheTransactionInfoById = {}) {
+    if (!acc) {
+        return defaultTronResources;
+    }
+    const delegatedFrozenBandwidth = get(acc, "delegated_frozenV2_balance_for_bandwidth", undefined);
+    const delegatedFrozenEnergy = get(acc, "account_resource.delegated_frozenV2_balance_for_energy", undefined);
+    const frozenBalances = get(acc, "frozenV2", undefined);
+    const legacyFrozenBandwidth = get(acc, "frozen[0]", undefined);
+    const legacyFrozenEnergy = get(acc, "account_resource.frozen_balance_for_energy", undefined);
+    const legacyFrozen = {
+        bandwidth: legacyFrozenBandwidth
+            ? {
+                amount: new BigNumber(legacyFrozenBandwidth.frozen_balance),
+                expiredAt: new Date(legacyFrozenBandwidth.expire_time),
+            }
+            : undefined,
+        energy: legacyFrozenEnergy
+            ? {
+                amount: new BigNumber(legacyFrozenEnergy.frozen_balance),
+                expiredAt: new Date(legacyFrozenEnergy.expire_time),
+            }
+            : undefined,
+    };
+    const { frozenEnergy, frozenBandwidth } = frozenBalances.reduce((accum, cur) => {
+        const amount = new BigNumber(cur?.amount ?? 0);
+        if (cur.type === "ENERGY") {
+            accum.frozenEnergy = accum.frozenEnergy.plus(amount);
         }
-        const delegatedFrozenBandwidth = get(acc, "delegated_frozenV2_balance_for_bandwidth", undefined);
-        const delegatedFrozenEnergy = get(acc, "account_resource.delegated_frozenV2_balance_for_energy", undefined);
-        const frozenBalances = get(acc, "frozenV2", undefined);
-        const legacyFrozenBandwidth = get(acc, "frozen[0]", undefined);
-        const legacyFrozenEnergy = get(acc, "account_resource.frozen_balance_for_energy", undefined);
-        const legacyFrozen = {
-            bandwidth: legacyFrozenBandwidth
-                ? {
-                    amount: new BigNumber(legacyFrozenBandwidth.frozen_balance),
-                    expiredAt: new Date(legacyFrozenBandwidth.expire_time),
-                }
-                : undefined,
-            energy: legacyFrozenEnergy
-                ? {
-                    amount: new BigNumber(legacyFrozenEnergy.frozen_balance),
-                    expiredAt: new Date(legacyFrozenEnergy.expire_time),
-                }
-                : undefined,
-        };
-        const { frozenEnergy, frozenBandwidth } = frozenBalances.reduce((accum, cur) => {
-            var _a;
-            const amount = new BigNumber((_a = cur === null || cur === void 0 ? void 0 : cur.amount) !== null && _a !== void 0 ? _a : 0);
-            if (cur.type === "ENERGY") {
-                accum.frozenEnergy = accum.frozenEnergy.plus(amount);
+        else if (cur.type === undefined) {
+            accum.frozenBandwidth = accum.frozenBandwidth.plus(amount);
+        }
+        return accum;
+    }, {
+        frozenEnergy: new BigNumber(0),
+        frozenBandwidth: new BigNumber(0),
+    });
+    const unFrozenBalances = get(acc, "unfrozenV2", undefined);
+    const unFrozen = unFrozenBalances
+        ? unFrozenBalances.reduce((accum, cur) => {
+            if (cur && cur.type === "ENERGY") {
+                accum.energy.push({
+                    amount: new BigNumber(cur.unfreeze_amount),
+                    expireTime: new Date(cur.unfreeze_expire_time),
+                });
             }
-            else if (cur.type === undefined) {
-                accum.frozenBandwidth = accum.frozenBandwidth.plus(amount);
+            else if (cur) {
+                accum.bandwidth.push({
+                    amount: new BigNumber(cur.unfreeze_amount),
+                    expireTime: new Date(cur.unfreeze_expire_time),
+                });
             }
             return accum;
-        }, {
-            frozenEnergy: new BigNumber(0),
-            frozenBandwidth: new BigNumber(0),
-        });
-        const unFrozenBalances = get(acc, "unfrozenV2", undefined);
-        const unFrozen = unFrozenBalances
-            ? unFrozenBalances.reduce((accum, cur) => {
-                if (cur && cur.type === "ENERGY") {
-                    accum.energy.push({
-                        amount: new BigNumber(cur.unfreeze_amount),
-                        expireTime: new Date(cur.unfreeze_expire_time),
-                    });
-                }
-                else if (cur) {
-                    accum.bandwidth.push({
-                        amount: new BigNumber(cur.unfreeze_amount),
-                        expireTime: new Date(cur.unfreeze_expire_time),
-                    });
-                }
-                return accum;
-            }, { bandwidth: [], energy: [] })
-            : { bandwidth: [], energy: [] };
-        const encodedAddress = encode58Check(acc.address);
-        const tronNetworkInfo = yield getTronAccountNetwork(encodedAddress);
-        const unwithdrawnReward = yield getUnwithdrawnReward(encodedAddress);
-        const energy = tronNetworkInfo.energyLimit.minus(tronNetworkInfo.energyUsed);
-        const bandwidth = extractBandwidthInfo(tronNetworkInfo);
-        const frozen = {
-            bandwidth: frozenBandwidth.isGreaterThan(0)
-                ? {
-                    amount: frozenBandwidth,
-                }
-                : undefined,
-            energy: frozenEnergy.isGreaterThan(0)
-                ? {
-                    amount: frozenEnergy,
-                }
-                : undefined,
-        };
-        const delegatedFrozen = {
-            bandwidth: delegatedFrozenBandwidth
-                ? {
-                    amount: new BigNumber(delegatedFrozenBandwidth),
-                }
-                : undefined,
-            energy: delegatedFrozenEnergy
-                ? {
-                    amount: new BigNumber(delegatedFrozenEnergy),
-                }
-                : undefined,
-        };
-        const tronPower = new BigNumber(get(frozen, "bandwidth.amount", 0))
-            .plus(get(frozen, "energy.amount", 0))
-            .plus(get(delegatedFrozen, "bandwidth.amount", 0))
-            .plus(get(delegatedFrozen, "energy.amount", 0))
-            .plus(get(legacyFrozen, "energy.amount", 0))
-            .plus(get(legacyFrozen, "bandwidth.amount", 0))
-            .dividedBy(1000000)
-            .integerValue(BigNumber.ROUND_FLOOR)
-            .toNumber();
-        const votes = get(acc, "votes", []).map((v) => ({
-            address: v.vote_address,
-            voteCount: v.vote_count,
-        }));
-        const lastWithdrawnRewardDate = acc.latest_withdraw_time
-            ? new Date(acc.latest_withdraw_time)
-            : undefined;
-        // TODO: rely on the account object when trongrid will provide this info.
-        const getLastVotedDate = (txs) => {
-            const lastOp = txs.find(({ type }) => type === "VoteWitnessContract");
-            return lastOp ? lastOp.date : null;
-        };
-        const lastVotedDate = txs ? getLastVotedDate(txs) : undefined;
-        return {
-            energy,
-            bandwidth,
-            frozen,
-            unFrozen,
-            delegatedFrozen,
-            legacyFrozen,
-            votes,
-            tronPower,
-            unwithdrawnReward,
-            lastWithdrawnRewardDate,
-            lastVotedDate,
-            cacheTransactionInfoById,
-        };
-    });
+        }, { bandwidth: [], energy: [] })
+        : { bandwidth: [], energy: [] };
+    const encodedAddress = encode58Check(acc.address);
+    const tronNetworkInfo = await getTronAccountNetwork(encodedAddress);
+    const unwithdrawnReward = await getUnwithdrawnReward(encodedAddress);
+    const energy = tronNetworkInfo.energyLimit.minus(tronNetworkInfo.energyUsed);
+    const bandwidth = extractBandwidthInfo(tronNetworkInfo);
+    const frozen = {
+        bandwidth: frozenBandwidth.isGreaterThan(0)
+            ? {
+                amount: frozenBandwidth,
+            }
+            : undefined,
+        energy: frozenEnergy.isGreaterThan(0)
+            ? {
+                amount: frozenEnergy,
+            }
+            : undefined,
+    };
+    const delegatedFrozen = {
+        bandwidth: delegatedFrozenBandwidth
+            ? {
+                amount: new BigNumber(delegatedFrozenBandwidth),
+            }
+            : undefined,
+        energy: delegatedFrozenEnergy
+            ? {
+                amount: new BigNumber(delegatedFrozenEnergy),
+            }
+            : undefined,
+    };
+    const tronPower = new BigNumber(get(frozen, "bandwidth.amount", 0))
+        .plus(get(frozen, "energy.amount", 0))
+        .plus(get(delegatedFrozen, "bandwidth.amount", 0))
+        .plus(get(delegatedFrozen, "energy.amount", 0))
+        .plus(get(legacyFrozen, "energy.amount", 0))
+        .plus(get(legacyFrozen, "bandwidth.amount", 0))
+        .dividedBy(1000000)
+        .integerValue(BigNumber.ROUND_FLOOR)
+        .toNumber();
+    const votes = get(acc, "votes", []).map((v) => ({
+        address: v.vote_address,
+        voteCount: v.vote_count,
+    }));
+    const lastWithdrawnRewardDate = acc.latest_withdraw_time
+        ? new Date(acc.latest_withdraw_time)
+        : undefined;
+    // TODO: rely on the account object when trongrid will provide this info.
+    const getLastVotedDate = (txs) => {
+        const lastOp = txs.find(({ type }) => type === "VoteWitnessContract");
+        return lastOp ? lastOp.date : null;
+    };
+    const lastVotedDate = txs ? getLastVotedDate(txs) : undefined;
+    return {
+        energy,
+        bandwidth,
+        frozen,
+        unFrozen,
+        delegatedFrozen,
+        legacyFrozen,
+        votes,
+        tronPower,
+        unwithdrawnReward,
+        lastWithdrawnRewardDate,
+        lastVotedDate,
+        cacheTransactionInfoById,
+    };
 }
-export const getUnwithdrawnReward = (addr) => __awaiter(void 0, void 0, void 0, function* () {
+export const getUnwithdrawnReward = async (addr) => {
     try {
-        const { reward = 0 } = yield fetch(`/wallet/getReward?address=${encodeURIComponent(decode58Check(addr))}`);
+        const { reward = 0 } = await fetch(`/wallet/getReward?address=${encodeURIComponent(decode58Check(addr))}`);
         return new BigNumber(reward);
     }
     catch (e) {
         return Promise.resolve(new BigNumber(0));
     }
-});
-export const claimRewardTronTransaction = (account) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const claimRewardTronTransaction = async (account) => {
     const url = `/wallet/withdrawbalance`;
     const data = {
         owner_address: decode58Check(account.freshAddress),
     };
-    const result = yield post(url, data);
+    const result = await post(url, data);
     return result;
-});
+};
 //# sourceMappingURL=index.js.map