@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/src/families/tron/bridge.integration.test.ts

@@ -23,9 +23,9 @@ import {
 } from "./errors";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
 import "../../__tests__/test-helpers/setup";
-import { activationFees } from "./constants";
+import { ACTIVATION_FEES } from "./constants";
 import { fromTransactionRaw } from "./transaction";
-import type { Transaction } from "./types";
+import type { Transaction, TronAccountRaw } from "./types";
 
 const unactivatedAddress = "TXFeV31qgUQYMLog3axKJeEBbXpQFtHsXD";
 const activatedAddress1 = "TRqkRnAj6ceJFYAn2p1eE7aWrgBBwtdhS9";
@@ -413,7 +413,7 @@ const tron: CurrenciesData<Transaction> = {
             recipient: unactivatedAddress,
           }),
           expectedStatus: () => ({
-            estimatedFees: activationFees,
+            estimatedFees: ACTIVATION_FEES,
           }),
         },
         {
@@ -421,7 +421,7 @@ const tron: CurrenciesData<Transaction> = {
           transaction: (t, account) => ({
             ...t,
             recipient: unactivatedAddress,
-            amount: account.spendableBalance.minus(activationFees).minus(1),
+            amount: account.spendableBalance.minus(ACTIVATION_FEES).minus(1),
           }),
           expectedStatus: () => ({
             errors: {},
@@ -432,7 +432,7 @@ const tron: CurrenciesData<Transaction> = {
           transaction: (t, account) => ({
             ...t,
             recipient: unactivatedAddress,
-            amount: account.spendableBalance.minus(activationFees),
+            amount: account.spendableBalance.minus(ACTIVATION_FEES),
           }),
           expectedStatus: () => ({
             errors: {},
@@ -757,7 +757,29 @@ const tron: CurrenciesData<Transaction> = {
         operations: [],
         lastSyncDate: "",
         blockHeight: 0,
-      },
+        tronResources: {
+          frozen: { bandwidth: undefined, energy: undefined },
+          delegatedFrozen: { bandwidth: undefined, energy: undefined },
+          unFrozen: { bandwidth: [], energy: [] },
+          legacyFrozen: {
+            bandwidth: { amount: "2000000", expiredAt: "2022-05-23T08:20:39.000Z" },
+            energy: { amount: "1000000", expiredAt: "2022-05-22T12:51:12.000Z" },
+          },
+          votes: [],
+          tronPower: 3,
+          energy: "12",
+          bandwidth: {
+            freeUsed: "0",
+            freeLimit: "600",
+            gainedUsed: "0",
+            gainedLimit: "2",
+          },
+          unwithdrawnReward: "0",
+          lastWithdrawnRewardDate: undefined,
+          lastVotedDate: undefined,
+          cacheTransactionInfoById: {},
+        },
+      } as TronAccountRaw,
     },
     {
       transactions: [
@@ -835,7 +857,33 @@ const tron: CurrenciesData<Transaction> = {
         operations: [],
         lastSyncDate: "",
         blockHeight: 0,
-      },
+        tronResources: {
+          frozen: { bandwidth: undefined, energy: undefined },
+          delegatedFrozen: { bandwidth: undefined, energy: undefined },
+          unFrozen: { bandwidth: [], energy: [] },
+          legacyFrozen: {
+            bandwidth: undefined,
+            energy: { amount: "26000000", expiredAt: "2020-02-01T16:04:51.000Z" },
+          },
+          votes: [
+            { address: "TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH", voteCount: 15 },
+            { address: "TGj1Ej1qRzL9feLTLhjwgxXF4Ct6GTWg2U", voteCount: 1 },
+            { address: "TCZvvbn4SCVyNhCAt1L8Kp1qk5rtMiKdBB", voteCount: 2 },
+          ],
+          tronPower: 26,
+          energy: "326",
+          bandwidth: {
+            freeUsed: "0",
+            freeLimit: "600",
+            gainedUsed: "0",
+            gainedLimit: "0",
+          },
+          unwithdrawnReward: "1336847",
+          lastWithdrawnRewardDate: "2022-05-19T12:45:36.000Z",
+          lastVotedDate: "2022-05-19T12:43:42.000Z",
+          cacheTransactionInfoById: {},
+        },
+      } as TronAccountRaw,
     },
     {
       transactions: [

package/src/families/tron/broadcast.ts

@@ -0,0 +1,20 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { broadcastTron } from "./api";
+import { Transaction } from "./types";
+
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation, rawData },
+}) => {
+  const transaction = {
+    raw_data: rawData,
+    txID: operation.hash,
+    signature: [signature],
+  };
+  const submittedTransaction = await broadcastTron(transaction);
+
+  if (submittedTransaction.result !== true) {
+    throw new Error(submittedTransaction.resultMessage);
+  }
+
+  return operation;
+};

package/src/families/tron/buildOptimisticOperation.ts

@@ -0,0 +1,133 @@
+import get from "lodash/get";
+import BigNumber from "bignumber.js";
+import { TokenAccount } from "@ledgerhq/types-live";
+import {
+  Transaction,
+  TronAccount,
+  TronOperation,
+  TronResource,
+  TrongridExtraTxInfo,
+} from "./types";
+import { encodeOperationId } from "../../operation";
+import { getOperationTypefromMode } from "./utils";
+
+const getValue = (
+  account: TronAccount,
+  subAccount: TokenAccount | undefined,
+  transaction: Transaction,
+  fee: BigNumber,
+): BigNumber => {
+  switch (transaction.mode) {
+    case "send":
+      return subAccount ? fee : new BigNumber(transaction.amount || 0).plus(fee);
+
+    case "claimReward": {
+      return account.tronResources ? account.tronResources.unwithdrawnReward : new BigNumber(0);
+    }
+
+    default:
+      return new BigNumber(0);
+  }
+};
+
+const getExtra = (
+  account: TronAccount,
+  transaction: Transaction,
+  resource: TronResource,
+): TrongridExtraTxInfo | null | undefined => {
+  switch (transaction.mode) {
+    case "freeze":
+      return {
+        frozenAmount: transaction.amount,
+      };
+
+    case "unfreeze":
+      return {
+        unfreezeAmount: transaction.amount,
+      };
+
+    case "vote":
+      return {
+        votes: transaction.votes,
+      };
+
+    case "unDelegateResource":
+      return {
+        unDelegatedAmount: transaction.amount,
+        receiverAddress: transaction.recipient,
+      };
+
+    case "legacyUnfreeze":
+      return {
+        unfreezeAmount: get(
+          account.tronResources,
+          `frozen.${resource.toLocaleLowerCase()}.amount`,
+          new BigNumber(0),
+        ),
+      };
+
+    default:
+      return undefined;
+  }
+};
+
+export const buildOptimisticOperation = (
+  account: TronAccount,
+  subAccount: TokenAccount | undefined,
+  transaction: Transaction,
+  fee: BigNumber,
+  hash: string,
+): TronOperation => {
+  const value = getValue(account, subAccount, transaction, fee);
+  const operationType = getOperationTypefromMode(transaction.mode);
+  const resource = transaction.resource || "BANDWIDTH";
+  const extra = getExtra(account, transaction, resource) || {};
+
+  /**
+   * FIXME
+   *
+   * This is not working and cannot work simply because this "NONE" type doesn't exist during a sync,
+   * as well as subOperations which are never created either.
+   *
+   * And even after fixing this,  we're getting wrong fee estimation for TRC20 transactions
+   * which are considered as 0 all the time, while it always being between 1 and 10 TRX.
+   */
+  const operation: TronOperation = {
+    id: encodeOperationId(account.id, hash, operationType),
+    hash,
+    // if it's a token op and there is no fee, this operation does not exist and is a "NONE"
+    type: subAccount && value.eq(0) ? "NONE" : operationType,
+    value,
+    fee,
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient],
+    accountId: account.id,
+    date: new Date(),
+    extra,
+    subOperations: subAccount
+      ? [
+          {
+            id: encodeOperationId(subAccount.id, hash, "OUT"),
+            hash,
+            type: "OUT",
+            value:
+              transaction.useAllAmount && subAccount
+                ? subAccount.balance
+                : new BigNumber(transaction.amount || 0),
+            fee: new BigNumber(0),
+            blockHash: null,
+            blockHeight: null,
+            senders: [account.freshAddress],
+            recipients: [transaction.recipient],
+            accountId: subAccount.id,
+            date: new Date(),
+            extra: {},
+          },
+        ]
+      : [],
+  };
+
+  return operation;
+};

package/src/families/tron/constants.ts

@@ -1,3 +1,4 @@
 import { BigNumber } from "bignumber.js";
-export const oneTrx = new BigNumber(1000000);
-export const activationFees = new BigNumber(1000000);
+
+export const ONE_TRX = new BigNumber(1000000);
+export const ACTIVATION_FEES = new BigNumber(1000000);

package/src/families/tron/createTransaction.ts

@@ -0,0 +1,15 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import BigNumber from "bignumber.js";
+
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => ({
+  family: "tron",
+  amount: new BigNumber(0),
+  useAllAmount: false,
+  mode: "send",
+  duration: 3,
+  recipient: "",
+  networkInfo: null,
+  resource: null,
+  votes: [],
+});

package/src/families/tron/estimateMaxSpendable.ts

@@ -0,0 +1,34 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets/abandonseed";
+import { createTransaction } from "./createTransaction";
+import { getMainAccount } from "../../account";
+import { getEstimatedFees } from "./logic";
+import { fetchTronContract } from "./api";
+import { Transaction } from "./types";
+import BigNumber from "bignumber.js";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const isContract = transaction?.recipient
+    ? !!(await fetchTronContract(transaction.recipient))
+    : false;
+  const fees = await getEstimatedFees(
+    mainAccount,
+    {
+      ...createTransaction(account),
+      subAccountId: account.type === "TokenAccount" ? account.id : null,
+      ...transaction,
+      recipient: transaction?.recipient || getAbandonSeedAddress("tron"),
+      amount: new BigNumber(0),
+    },
+    isContract,
+  );
+
+  return account.type === "Account"
+    ? BigNumber.max(0, account.spendableBalance.minus(fees))
+    : account.balance;
+};

package/src/families/tron/getTransactionStatus.ts

@@ -0,0 +1,261 @@
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import get from "lodash/get";
+import sumBy from "lodash/sumBy";
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction, TronAccount } from "./types";
+import { findSubAccountById, getAccountCurrency } from "../../account";
+import {
+  TronInvalidFreezeAmount,
+  TronInvalidUnDelegateResourceAmount,
+  TronInvalidVoteCount,
+  TronLegacyUnfreezeNotExpired,
+  TronNoFrozenForBandwidth,
+  TronNoFrozenForEnergy,
+  TronNoReward,
+  TronNoUnfrozenResource,
+  TronNotEnoughEnergy,
+  TronNotEnoughTronPower,
+  TronRewardNotAvailable,
+  TronSendTrc20ToNewAccountForbidden,
+  TronUnexpectedFees,
+  TronUnfreezeNotExpired,
+  TronVoteRequired,
+} from "./errors";
+import {
+  fetchTronAccount,
+  fetchTronContract,
+  getContractUserEnergyRatioConsumption,
+  getDelegatedResource,
+  getTronSuperRepresentatives,
+  validateAddress,
+} from "./api";
+import { ONE_TRX } from "./constants";
+import { formatCurrencyUnit } from "../../currencies";
+import { getEstimatedFees } from "./logic";
+
+export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+  account: TronAccount,
+  transaction,
+) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  const { family, mode, recipient, resource, votes, useAllAmount = false } = transaction;
+  const tokenAccount = transaction?.subAccountId
+    ? findSubAccountById(account, transaction.subAccountId)
+    : undefined;
+  const acc = tokenAccount || account;
+  const isContractAddressRecipient = (await fetchTronContract(recipient)) !== undefined;
+
+  if (mode === "send" && !recipient) {
+    errors.recipient = new RecipientRequired();
+  }
+
+  if (["send", "unDelegateResource", "legacyUnfreeze"].includes(mode)) {
+    if (recipient === account.freshAddress) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    } else if (recipient && !(await validateAddress(recipient))) {
+      errors.recipient = new InvalidAddress(undefined, {
+        currencyName: account.currency.name,
+      });
+    } else if (
+      recipient &&
+      mode === "send" &&
+      acc.type === "TokenAccount" &&
+      acc.token.tokenType === "trc20" &&
+      !isContractAddressRecipient && // send trc20 to a smart contract is allowed
+      (await fetchTronAccount(recipient)).length === 0
+    ) {
+      // send trc20 to a new account is forbidden by us (because it will not activate the account)
+      errors.recipient = new TronSendTrc20ToNewAccountForbidden();
+    }
+  }
+
+  if (mode === "unfreeze") {
+    const { bandwidth, energy } = account.tronResources.frozen;
+    if (resource === "BANDWIDTH" && transaction.amount.gt(bandwidth?.amount || new BigNumber(0))) {
+      errors.resource = new TronNoFrozenForBandwidth();
+    } else if (resource === "ENERGY" && transaction.amount.gt(energy?.amount || new BigNumber(0))) {
+      errors.resource = new TronNoFrozenForEnergy();
+    }
+  }
+
+  if (mode === "legacyUnfreeze") {
+    const lowerCaseResource = resource ? resource.toLowerCase() : "bandwidth";
+    const now = new Date();
+    const expiredDatePath = `tronResources.legacyFrozen.${lowerCaseResource}.expiredAt`;
+    const expirationDate = get(account, expiredDatePath, undefined) as Date | null | undefined;
+    if (!expirationDate) {
+      if (resource === "BANDWIDTH") {
+        errors.resource = new TronNoFrozenForBandwidth();
+      } else {
+        errors.resource = new TronNoFrozenForEnergy();
+      }
+    } else if (now.getTime() < expirationDate.getTime()) {
+      errors.resource = new TronLegacyUnfreezeNotExpired();
+    }
+  }
+
+  if (mode === "withdrawExpireUnfreeze") {
+    const now = new Date();
+    if (
+      (!account.tronResources.unFrozen.bandwidth ||
+        account.tronResources.unFrozen.bandwidth.length === 0) &&
+      (!account.tronResources.unFrozen.energy || account.tronResources.unFrozen.energy.length === 0)
+    ) {
+      errors.resource = new TronNoUnfrozenResource();
+    } else {
+      const unfreezingResources = [
+        ...(account.tronResources.unFrozen.bandwidth ?? []),
+        ...(account.tronResources.unFrozen.energy ?? []),
+      ];
+
+      const hasNoExpiredResource = !unfreezingResources.some(
+        unfrozen => unfrozen.expireTime.getTime() <= now.getTime(),
+      );
+
+      if (hasNoExpiredResource) {
+        const closestExpireTime = unfreezingResources.reduce((closest, current) => {
+          if (!closest) {
+            return current;
+          }
+          const closestTimeDifference = Math.abs(closest.expireTime.getTime() - now.getTime());
+          const currentTimeDifference = Math.abs(current.expireTime.getTime() - now.getTime());
+
+          return currentTimeDifference < closestTimeDifference ? current : closest;
+        });
+        errors.resource = new TronUnfreezeNotExpired(undefined, {
+          time: closestExpireTime.expireTime.toISOString(),
+        });
+      }
+    }
+  }
+
+  if (mode === "unDelegateResource" && resource && account.tronResources) {
+    const delegatedResourceAmount = await getDelegatedResource(account, transaction, resource);
+    if (delegatedResourceAmount.lt(transaction.amount)) {
+      errors.resource = new TronInvalidUnDelegateResourceAmount();
+    }
+  }
+
+  if (mode === "vote") {
+    if (votes.length === 0) {
+      errors.vote = new TronVoteRequired();
+    } else {
+      const superRepresentatives = await getTronSuperRepresentatives();
+      const isValidVoteCounts = votes.every(v => v.voteCount > 0);
+      const isValidAddresses = votes.every(v =>
+        superRepresentatives.some(s => s.address === v.address),
+      );
+
+      if (!isValidAddresses) {
+        errors.vote = new InvalidAddress("", {
+          currencyName: account.currency.name,
+        });
+      } else if (!isValidVoteCounts) {
+        errors.vote = new TronInvalidVoteCount();
+      } else {
+        const totalVoteCount = sumBy(votes, "voteCount");
+        const tronPower = (account.tronResources && account.tronResources.tronPower) || 0;
+
+        if (totalVoteCount > tronPower) {
+          errors.vote = new TronNotEnoughTronPower();
+        }
+      }
+    }
+  }
+
+  if (mode === "claimReward") {
+    const lastRewardOp = acc.operations.find(o => o.type === "REWARD");
+    const claimableRewardDate = lastRewardOp
+      ? new Date(lastRewardOp.date.getTime() + 24 * 60 * 60 * 1000) // date + 24 hours
+      : new Date();
+
+    if (account.tronResources && account.tronResources.unwithdrawnReward.eq(0)) {
+      errors.reward = new TronNoReward();
+    } else if (lastRewardOp && claimableRewardDate.valueOf() > new Date().valueOf()) {
+      errors.reward = new TronRewardNotAvailable("Reward is not claimable", {
+        until: claimableRewardDate.toISOString(),
+      });
+    }
+  }
+
+  const estimatedFees =
+    Object.entries(errors).length > 0
+      ? new BigNumber(0)
+      : await getEstimatedFees(account, transaction, isContractAddressRecipient);
+  const balance =
+    acc.type === "Account"
+      ? BigNumber.max(0, acc.spendableBalance.minus(estimatedFees))
+      : acc.balance;
+  const amount = useAllAmount ? balance : transaction.amount;
+  const amountSpent = ["send", "freeze", "undelegateResource"].includes(mode)
+    ? amount
+    : new BigNumber(0);
+
+  if (mode === "freeze" && amount.lt(ONE_TRX)) {
+    errors.amount = new TronInvalidFreezeAmount();
+  }
+
+  // fees are applied in the parent only (TRX)
+  const totalSpent = acc.type === "Account" ? amountSpent.plus(estimatedFees) : amountSpent;
+
+  if (["send", "freeze"].includes(mode)) {
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    }
+    if (amountSpent.eq(0)) {
+      errors.amount = useAllAmount ? new NotEnoughBalance() : new AmountRequired();
+    } else if (amount.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    } else if (acc.type === "TokenAccount" && estimatedFees.gt(account.balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+
+    const energy = (account.tronResources && account.tronResources.energy) || new BigNumber(0);
+
+    // For the moment, we rely on this rule:
+    // Add a 'TronNotEnoughEnergy' warning only if the account sastifies theses 3 conditions:
+    // - no energy
+    // - balance is lower than 1 TRX
+    // - contract consumes user energy (ie: user's ratio > 0%)
+    if (
+      acc.type === "TokenAccount" &&
+      acc.token.tokenType === "trc20" &&
+      energy.lt(47619) // temporary value corresponding to usdt trc20 energy
+    ) {
+      const contractUserEnergyConsumption = await getContractUserEnergyRatioConsumption(
+        acc.token.contractAddress,
+      );
+
+      if (contractUserEnergyConsumption > 0) {
+        warnings.amount = new TronNotEnoughEnergy();
+      }
+    }
+  }
+
+  if (!errors.recipient && estimatedFees.gt(0)) {
+    const fees = formatCurrencyUnit(getAccountCurrency(account).units[0], estimatedFees, {
+      showCode: true,
+      disableRounding: true,
+    });
+    warnings.fee = new TronUnexpectedFees("Estimated fees", {
+      fees,
+    });
+  }
+
+  return {
+    errors,
+    warnings,
+    amount: amountSpent,
+    estimatedFees,
+    totalSpent,
+    family,
+  };
+};

package/src/families/tron/logic.ts

@@ -0,0 +1,59 @@
+import { Account } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import BigNumber from "bignumber.js";
+import { fetchTronAccount } from "./api";
+import { extractBandwidthInfo, getEstimatedBlockSize } from "./utils";
+import { ACTIVATION_FEES } from "./constants";
+
+export const getEstimatedFees = async (
+  account: Account,
+  transaction: Transaction,
+  isContract: boolean,
+) => {
+  const feesFromAccountActivation =
+    transaction.mode === "send" && !isContract
+      ? await getFeesFromAccountActivation(account, transaction)
+      : new BigNumber(0);
+
+  if (feesFromAccountActivation.gt(0)) {
+    return feesFromAccountActivation;
+  }
+
+  const feesFromBandwidth = getFeesFromBandwidth(account, transaction);
+  return feesFromBandwidth;
+};
+
+// Special case: If activated an account, cost around 0.1 TRX
+const getFeesFromAccountActivation = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<BigNumber> => {
+  const recipientAccount = await fetchTronAccount(transaction.recipient);
+  const { gainedUsed, gainedLimit } = extractBandwidthInfo(transaction.networkInfo);
+  const available = gainedLimit.minus(gainedUsed);
+  const estimatedBandwidthCost = getEstimatedBlockSize(account, transaction);
+
+  if (recipientAccount.length === 0 && available.lt(estimatedBandwidthCost)) {
+    return ACTIVATION_FEES; // cost is around 1 TRX
+  }
+
+  return new BigNumber(0); // no fee
+};
+
+// see : https://developers.tron.network/docs/bandwith#section-bandwidth-points-consumption
+// 1. cost around 200 Bandwidth, if not enough check Free Bandwidth
+// 2. If not enough, will cost some TRX
+// 3. normal transfert cost around 0.002 TRX
+const getFeesFromBandwidth = (account: Account, transaction: Transaction): BigNumber => {
+  const { freeUsed, freeLimit, gainedUsed, gainedLimit } = extractBandwidthInfo(
+    transaction.networkInfo,
+  );
+  const available = freeLimit.minus(freeUsed).plus(gainedLimit).minus(gainedUsed);
+  const estimatedBandwidthCost = getEstimatedBlockSize(account, transaction);
+
+  if (available.lt(estimatedBandwidthCost)) {
+    return new BigNumber(2000); // cost is around 0.002 TRX
+  }
+
+  return new BigNumber(0); // no fee
+};

package/src/families/tron/preload.ts

@@ -0,0 +1,27 @@
+import { CurrencyBridge } from "@ledgerhq/types-live";
+import { getTronSuperRepresentatives, hydrateSuperRepresentatives } from "./api";
+import { SuperRepresentative } from "./types";
+
+export const preload: CurrencyBridge["preload"] = async () => {
+  const superRepresentatives = await getTronSuperRepresentatives();
+  return {
+    superRepresentatives,
+  };
+};
+
+export const hydrate: CurrencyBridge["hydrate"] = (data?: {
+  superRepresentatives?: SuperRepresentative[];
+}) => {
+  if (!data || !data.superRepresentatives) return;
+
+  const { superRepresentatives } = data;
+
+  if (
+    !superRepresentatives ||
+    typeof superRepresentatives !== "object" ||
+    !Array.isArray(superRepresentatives)
+  ) {
+    return;
+  }
+  hydrateSuperRepresentatives(superRepresentatives);
+};

package/src/families/tron/prepareTransaction.ts

@@ -0,0 +1,12 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getTronAccountNetwork } from "./api";
+import { Transaction } from "./types";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  const networkInfo =
+    transaction.networkInfo || (await getTronAccountNetwork(account.freshAddress));
+  return transaction.networkInfo === networkInfo ? transaction : { ...transaction, networkInfo };
+};