@ledgerhq/coin-tron 0.0.1

package/src/bridge/signOperation.ts

@@ -0,0 +1,123 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { SignOperationEvent, SignOperationFnSignature, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { Observable } from "rxjs";
+import {
+  claimRewardTronTransaction,
+  createTronTransaction,
+  fetchTronContract,
+  freezeTronTransaction,
+  legacyUnfreezeTronTransaction,
+  unDelegateResourceTransaction,
+  unfreezeTronTransaction,
+  voteTronSuperRepresentatives,
+  withdrawExpireUnfreezeTronTransaction,
+} from "../network";
+import { Transaction, TronAccount, TronSigner } from "../types";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import getEstimatedFees from "./getEstimateFees";
+
+export const buildSignOperation =
+  (signerContext: SignerContext<TronSigner>): SignOperationFnSignature<Transaction, TronAccount> =>
+  ({ account, transaction, deviceId }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      async function main() {
+        const subAccount =
+          transaction.subAccountId && account.subAccounts
+            ? account.subAccounts.find(sa => sa.id === transaction.subAccountId)
+            : undefined;
+        const isContractAddressRecipient =
+          (await fetchTronContract(transaction.recipient)) !== undefined;
+        const fee = await getEstimatedFees(account, transaction, isContractAddressRecipient);
+        const balance = subAccount
+          ? subAccount.balance
+          : BigNumber.max(0, account.spendableBalance.minus(fee));
+
+        if (transaction.useAllAmount) {
+          transaction = { ...transaction }; // transaction object must not be mutated
+          transaction.amount = balance; // force the amount to be the max
+        }
+
+        const {
+          raw_data_hex: rawDataHex,
+          raw_data: rawData,
+          txID: hash,
+        } = await prepareTransactionForSignature(account, subAccount, transaction);
+
+        o.next({
+          type: "device-signature-requested",
+        });
+
+        const txArg = {
+          rawDataHex,
+          // only for trc10, we need to put the token ledger signature
+          tokenSignature:
+            subAccount &&
+            subAccount.type === "TokenAccount" &&
+            subAccount.token.id.includes("trc10")
+              ? subAccount.token.ledgerSignature
+              : undefined,
+        };
+
+        // Sign by device
+        const signature = await signerContext(deviceId, signer =>
+          signer.sign(
+            account.freshAddressPath,
+            txArg.rawDataHex ?? "", //FIXME: why rawDataHex could be undefined? This shouldn't be the case.
+            txArg.tokenSignature ? [txArg.tokenSignature] : [],
+          ),
+        );
+
+        o.next({
+          type: "device-signature-granted",
+        });
+
+        const operation = buildOptimisticOperation(account, subAccount, transaction, fee, hash);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature,
+            rawData,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });
+
+const prepareTransactionForSignature = (
+  account: TronAccount,
+  subAccount: TokenAccount | undefined,
+  transaction: Transaction,
+) => {
+  switch (transaction.mode) {
+    case "freeze":
+      return freezeTronTransaction(account, transaction);
+
+    case "unfreeze":
+      return unfreezeTronTransaction(account, transaction);
+
+    case "vote":
+      return voteTronSuperRepresentatives(account, transaction);
+
+    case "claimReward":
+      return claimRewardTronTransaction(account);
+
+    case "withdrawExpireUnfreeze":
+      return withdrawExpireUnfreezeTronTransaction(account, transaction);
+
+    case "unDelegateResource":
+      return unDelegateResourceTransaction(account, transaction);
+
+    case "legacyUnfreeze":
+      return legacyUnfreezeTronTransaction(account, transaction);
+
+    default:
+      return createTronTransaction(account, transaction, subAccount);
+  }
+};

package/src/bridge/synchronization.integ.test.ts

@@ -0,0 +1,105 @@
+import BigNumber from "bignumber.js";
+import { firstValueFrom, reduce } from "rxjs";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { Account, AccountBridge, SyncConfig, TransactionCommon } from "@ledgerhq/types-live";
+import { TronCoinConfig } from "../config";
+import { defaultTronResources } from "../logic/utils";
+import { Transaction, TronAccount } from "../types";
+import { createBridges } from "./index";
+
+jest.setTimeout(30000);
+
+const tron = getCryptoCurrencyById("tron");
+const defaultSyncConfig = {
+  paginationConfig: {},
+  blacklistedTokenIds: [],
+};
+export function syncAccount<T extends TransactionCommon, A extends Account = Account>(
+  bridge: AccountBridge<T, A>,
+  account: A,
+  syncConfig: SyncConfig = defaultSyncConfig,
+): Promise<A> {
+  return firstValueFrom(
+    bridge.sync(account, syncConfig).pipe(reduce((a, f: (arg0: A) => A) => f(a), account)),
+  );
+}
+
+const dummyAccount: TronAccount = {
+  type: "Account",
+  id: "",
+  derivationMode: "",
+  seedIdentifier: "",
+  used: false,
+  currency: tron,
+  index: 0,
+  freshAddress: "",
+  freshAddressPath: "",
+  swapHistory: [],
+  blockHeight: 0,
+  balance: new BigNumber(0),
+  spendableBalance: new BigNumber(0),
+  operationsCount: 0,
+  operations: [],
+  pendingOperations: [],
+  lastSyncDate: new Date(0),
+  creationDate: new Date(),
+  balanceHistoryCache: {
+    HOUR: {
+      balances: [],
+      latestDate: undefined,
+    },
+    DAY: {
+      balances: [],
+      latestDate: undefined,
+    },
+    WEEK: {
+      balances: [],
+      latestDate: undefined,
+    },
+  },
+  tronResources: {} as any,
+};
+
+describe("Tron Accounts", () => {
+  let bridge: ReturnType<typeof createBridges>;
+
+  beforeAll(() => {
+    const signer = jest.fn();
+    const coinConfig = (): TronCoinConfig => ({
+      status: {
+        type: "active",
+      },
+      explorer: {
+        url: "https://tron.coin.ledger.com",
+      },
+    });
+    bridge = createBridges(signer, coinConfig);
+  });
+
+  test("should always have tronResources", async () => {
+    const account = await syncAccount<Transaction, TronAccount>(
+      bridge.accountBridge,
+      dummyAccount,
+      defaultSyncConfig,
+    );
+
+    expect(account.tronResources).toEqual(defaultTronResources);
+  });
+
+  test.each([
+    "TL24LCps5FKwp3PoU1MvrYrwhi5LU1tHre",
+    "TAVrrARNdnjHgCGMQYeQV7hv4PSu7mVsMj",
+    "THAe4BNVxp293qgyQEqXEkHMpPcqtG73bi",
+    "TRqkRnAj6ceJFYAn2p1eE7aWrgBBwtdhS9",
+    "TUxd6v64YTWkfpFpNDdtgc5Ps4SfGxwizT",
+    "TY2ksFgpvb82TgGPwUSa7iseqPW5weYQyh",
+  ])("should always be sync wihtout error for address %s", async (accountId: string) => {
+    const account = await syncAccount<Transaction, TronAccount>(
+      bridge.accountBridge,
+      { ...dummyAccount, id: `js:2:tron:${accountId}:`, freshAddress: accountId },
+      defaultSyncConfig,
+    );
+
+    expect(account.id).toEqual(`js:2:tron:${accountId}:`);
+  });
+});

package/src/bridge/synchronization.ts

@@ -0,0 +1,284 @@
+import {
+  emptyHistoryCache,
+  encodeAccountId,
+  encodeTokenAccountId,
+} from "@ledgerhq/coin-framework/account";
+import { GetAccountShape, makeSync } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { findTokenByAddressInCurrency, findTokenById } from "@ledgerhq/cryptoassets/index";
+import { Account, SubAccount, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import compact from "lodash/compact";
+import get from "lodash/get";
+import { getOperationsPageSize } from "../logic/pagination";
+import { isParentTx, txInfoToOperation } from "../logic/utils";
+import {
+  fetchCurrentBlockHeight,
+  fetchTronAccount,
+  fetchTronAccountTxs,
+  getTronResources,
+} from "../network";
+import { TronAccount, TrongridExtraTxInfo, TronOperation } from "../types";
+
+type TronToken = {
+  key: string;
+  type: "trc10" | "trc20";
+  tokenId: string;
+  balance: string;
+};
+
+// the balance does not update straightaway so we should ignore recent operations if they are in pending for a bit
+const PREFER_PENDING_OPERATIONS_UNTIL_BLOCK_VALIDATION = 35;
+
+export const getAccountShape: GetAccountShape<TronAccount> = async (
+  { initialAccount, currency, address, derivationMode },
+  syncConfig,
+) => {
+  const blockHeight = await fetchCurrentBlockHeight();
+  const tronAcc = await fetchTronAccount(address);
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode: derivationMode,
+  });
+
+  if (tronAcc.length === 0) {
+    const defaultTronResources = await getTronResources();
+
+    return {
+      id: accountId,
+      blockHeight,
+      balance: new BigNumber(0),
+      tronResources: defaultTronResources,
+    };
+  }
+
+  const acc = tronAcc[0];
+  const spendableBalance = acc.balance ? new BigNumber(acc.balance) : new BigNumber(0);
+  const cacheTransactionInfoById = initialAccount
+    ? {
+        ...(initialAccount?.tronResources?.cacheTransactionInfoById || {}),
+      }
+    : {};
+  const operationsPageSize = Math.min(
+    1000,
+    getOperationsPageSize(initialAccount && initialAccount.id, syncConfig),
+  );
+  // FIXME: this is not optional especially that we might already have initialAccount
+  // use minimalOperationsBuilderSync to reconciliate and KEEP REF
+  const txs = await fetchTronAccountTxs(
+    address,
+    txs => txs.length < operationsPageSize,
+    cacheTransactionInfoById,
+  );
+
+  const tronResources = await getTronResources(acc, txs, cacheTransactionInfoById);
+  const balance = spendableBalance
+    .plus(tronResources.frozen.bandwidth ? tronResources.frozen.bandwidth.amount : new BigNumber(0))
+    .plus(tronResources.frozen.energy ? tronResources.frozen.energy.amount : new BigNumber(0))
+    .plus(
+      tronResources.delegatedFrozen.bandwidth
+        ? tronResources.delegatedFrozen.bandwidth.amount
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.delegatedFrozen.energy
+        ? tronResources.delegatedFrozen.energy.amount
+        : new BigNumber(0),
+    )
+
+    .plus(
+      tronResources.unFrozen.energy
+        ? tronResources.unFrozen.energy.reduce((accum, cur) => {
+            return accum.plus(cur.amount);
+          }, new BigNumber(0))
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.unFrozen.bandwidth
+        ? tronResources.unFrozen.bandwidth.reduce((accum, cur) => {
+            return accum.plus(cur.amount);
+          }, new BigNumber(0))
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.legacyFrozen.bandwidth
+        ? tronResources.legacyFrozen.bandwidth.amount
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.legacyFrozen.energy
+        ? tronResources.legacyFrozen.energy.amount
+        : new BigNumber(0),
+    );
+
+  const parentTxs = txs.filter(isParentTx);
+  const parentOperations: TronOperation[] = compact(
+    parentTxs.map(tx => txInfoToOperation(accountId, address, tx)),
+  );
+
+  const trc10Tokens = get(acc, "assetV2", []).reduce(
+    (accumulator: TronToken[], { key, value }: { key: string; value: string }) => {
+      const tokenInfo = findTokenById(`tron/trc10/${key}`);
+      if (tokenInfo) {
+        accumulator.push({
+          key,
+          type: "trc10",
+          tokenId: tokenInfo.id,
+          balance: value,
+        });
+      }
+      return accumulator;
+    },
+    [],
+  );
+
+  const trc20Tokens = get(acc, "trc20", []).reduce((accumulator: TronToken[], trc20: TronToken) => {
+    const [[contractAddress, balance]] = Object.entries(trc20);
+    const tokenInfo = findTokenByAddressInCurrency(contractAddress, currency.id);
+    if (tokenInfo) {
+      accumulator.push({
+        key: contractAddress,
+        type: "trc20",
+        tokenId: tokenInfo.id,
+        balance,
+      });
+    }
+    return accumulator;
+  }, []);
+
+  const { blacklistedTokenIds = [] } = syncConfig;
+
+  const subAccounts: SubAccount[] = compact(
+    trc10Tokens.concat(trc20Tokens).map(({ key, tokenId, balance }: TronToken) => {
+      const { blacklistedTokenIds = [] } = syncConfig;
+      const token = findTokenById(tokenId);
+      if (!token || blacklistedTokenIds.includes(tokenId)) return;
+      const id = encodeTokenAccountId(accountId, token);
+      const tokenTxs = txs.filter(tx => tx.tokenId === key);
+      const operations = compact(tokenTxs.map(tx => txInfoToOperation(id, address, tx)));
+      const maybeExistingSubAccount = initialAccount?.subAccounts?.find(a => a.id === id);
+      const bnBalance = new BigNumber(balance);
+      const sub: TokenAccount = {
+        type: "TokenAccount",
+        id,
+        parentId: accountId,
+        token,
+        balance: bnBalance,
+        spendableBalance: bnBalance,
+        operationsCount: operations.length,
+        operations,
+        pendingOperations: maybeExistingSubAccount ? maybeExistingSubAccount.pendingOperations : [],
+        creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
+        swapHistory: maybeExistingSubAccount ? maybeExistingSubAccount.swapHistory : [],
+        balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+      };
+      return sub;
+    }),
+  );
+
+  // Filter blacklisted tokens from the initial account's subAccounts
+  // Could be use to filter out tokens that got their CAL id changed
+  const filteredInitialSubAccounts = (initialAccount?.subAccounts || []).filter(
+    subAccount => !blacklistedTokenIds.includes(subAccount.token.id),
+  );
+
+  // keep old account with emptyBalance and a history not returned by the BE fixes LIVE-12797
+  const mergedSubAccounts = mergeSubAccounts(subAccounts, filteredInitialSubAccounts);
+
+  // get 'OUT' token operations with fee
+  const subOutOperationsWithFee: TronOperation[] = subAccounts
+    .flatMap(s => s.operations)
+    .filter(o => o.type === "OUT" && o.fee.isGreaterThan(0))
+    .map(
+      (o): TronOperation => ({
+        ...o,
+        accountId,
+        value: o.fee,
+        id: encodeOperationId(accountId, o.hash, "OUT"),
+        extra: o.extra as TrongridExtraTxInfo,
+      }),
+    );
+  // add them to the parent operations and sort by date desc
+
+  /**
+   * FIXME
+   *
+   * We have a problem here as we're just concatenating ops without ever really linking them.
+   * It means no operation can be "FEES" of a subOp by example. It leads to our issues with TRC10/TRC20
+   * optimistic operation never really existing in the end.
+   */
+  const parentOpsAndSubOutOpsWithFee = parentOperations
+    .concat(subOutOperationsWithFee)
+    .sort((a, b) => b.date.valueOf() - a.date.valueOf());
+
+  return {
+    id: accountId,
+    balance,
+    spendableBalance,
+    operationsCount: parentOpsAndSubOutOpsWithFee.length,
+    operations: parentOpsAndSubOutOpsWithFee,
+    subAccounts: mergedSubAccounts,
+    tronResources,
+    blockHeight,
+  };
+};
+
+const postSync = (initial: TronAccount, parent: TronAccount): TronAccount => {
+  function evictRecentOpsIfPending(a: Account | TokenAccount) {
+    a.pendingOperations.forEach(pending => {
+      const i = a.operations.findIndex(o => o.id === pending.id);
+
+      if (i !== -1) {
+        const diff = parent.blockHeight - (a.operations[i].blockHeight || 0);
+
+        if (diff < PREFER_PENDING_OPERATIONS_UNTIL_BLOCK_VALIDATION) {
+          a.operations.splice(i, 1);
+        }
+      }
+    });
+  }
+
+  evictRecentOpsIfPending(parent);
+  parent.subAccounts && parent.subAccounts.forEach(evictRecentOpsIfPending);
+  return parent;
+};
+
+/**
+ * Merges two arrays of subAccounts according to specific rules:
+ * - The first array (subAccounts1) is up-to-date and should not be modified.
+ * - Old duplicates from the second array (subAccounts2) should be filtered out.
+ * - Only new subAccounts with a unique ID from the second array should be included.
+ * - The balance and spendableBalance fields of the second array's subAccounts should be set to 0.
+ *
+ * @param {Array} subAccounts1 - The first array of subAccounts, which is up-to-date and should not be modified.
+ * @param {Array} subAccounts2 - The second array of subAccounts, from which only new unique subAccounts should be included.
+ * @returns {Array} - The merged array of subAccounts.
+ */
+const mergeSubAccounts = (subAccounts1: TokenAccount[], subAccounts2: TokenAccount[]) => {
+  const existingIds = new Set(subAccounts1.map(subAccount => subAccount.id));
+  const filteredSubAccounts2: TokenAccount[] = subAccounts2
+    .map(subAccount => {
+      if (existingIds.has(subAccount.id)) {
+        return null;
+      } else {
+        // Set balance and spendableBalance to 0 has if they are not here it means balance is 0
+        return {
+          ...subAccount,
+          balance: new BigNumber(0),
+          spendableBalance: new BigNumber(0),
+        };
+      }
+    })
+    .filter((elt): elt is NonNullable<typeof elt> => elt !== null);
+
+  return subAccounts1.concat(filteredSubAccounts2);
+};
+
+export const sync = makeSync({
+  getAccountShape,
+  postSync,
+});

package/src/bridge/transaction.ts

@@ -0,0 +1,84 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction, TransactionRaw } from "../types";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  const { networkInfo } = tr;
+  return {
+    ...common,
+    networkInfo: networkInfo && {
+      family: "tron",
+      freeNetUsed: new BigNumber(networkInfo.freeNetUsed),
+      freeNetLimit: new BigNumber(networkInfo.freeNetLimit),
+      netUsed: new BigNumber(networkInfo.netUsed),
+      netLimit: new BigNumber(networkInfo.netLimit),
+      energyUsed: new BigNumber(networkInfo.energyUsed),
+      energyLimit: new BigNumber(networkInfo.energyLimit),
+    },
+    family: tr.family,
+    mode: tr.mode,
+    resource: tr.resource || null,
+    duration: tr.duration || 3,
+    votes: tr.votes,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  const { networkInfo } = t;
+  return {
+    ...common,
+    networkInfo: networkInfo && {
+      family: "tron",
+      freeNetUsed: networkInfo.freeNetUsed.toString(),
+      freeNetLimit: networkInfo.freeNetLimit.toString(),
+      netUsed: networkInfo.netUsed.toString(),
+      netLimit: networkInfo.netLimit.toString(),
+      energyUsed: networkInfo.energyUsed.toString(),
+      energyLimit: networkInfo.energyLimit.toString(),
+    },
+    family: t.family,
+    mode: t.mode,
+    resource: t.resource || null,
+    duration: t.duration || 3,
+    votes: t.votes,
+  };
+};
+
+export const formatTransaction = (t: Transaction, mainAccount: Account): string => {
+  const account =
+    (t.subAccountId && (mainAccount.subAccounts || []).find(a => a.id === t.subAccountId)) ||
+    mainAccount;
+  return `
+${t.mode.toUpperCase()}${t.resource ? " " + t.resource : ""} ${
+    t.useAllAmount
+      ? "MAX"
+      : t.amount.isZero()
+        ? ""
+        : " " +
+          formatCurrencyUnit(getAccountCurrency(account).units[0], t.amount, {
+            showCode: true,
+            disableRounding: true,
+          })
+  }${!t.votes ? "" : " " + t.votes.map(v => v.voteCount + "->" + v.address).join(" ")}
+TO ${t.recipient}`;
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/config.ts

@@ -0,0 +1,24 @@
+import { CurrencyConfig, CoinConfig } from "@ledgerhq/coin-framework/config";
+import { MissingCoinConfig } from "@ledgerhq/coin-framework/errors";
+
+export type TronConfig = {
+  explorer: {
+    url: string;
+  };
+};
+
+export type TronCoinConfig = CurrencyConfig & TronConfig;
+
+let coinConfig: CoinConfig<TronCoinConfig> | undefined;
+
+export const setCoinConfig = (config: CoinConfig<TronCoinConfig>): void => {
+  coinConfig = config;
+};
+
+export const getCoinConfig = (): TronCoinConfig => {
+  if (!coinConfig) {
+    throw new MissingCoinConfig();
+  }
+
+  return coinConfig();
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+
+export { createBridges } from "./bridge/index";

package/src/logic/constants.ts

@@ -0,0 +1,4 @@
+import { BigNumber } from "bignumber.js";
+
+export const ONE_TRX = new BigNumber(1000000);
+export const ACTIVATION_FEES = new BigNumber(1100000); // ONE TRX fee + 0.1 TRX activation cost

package/src/logic/pagination.ts

@@ -0,0 +1,21 @@
+import type { SyncConfig } from "@ledgerhq/types-live";
+
+export function getOperationsPageSize(
+  accountId: string | null | undefined,
+  syncConfig: SyncConfig,
+): number {
+  const { paginationConfig } = syncConfig;
+  const { operationsPerAccountId, operations } = paginationConfig;
+  const numbers: number[] = [];
+
+  if (operationsPerAccountId && accountId && accountId in operationsPerAccountId) {
+    numbers.push(operationsPerAccountId[accountId]);
+  }
+
+  if (typeof operations === "number") {
+    numbers.push(operations);
+  }
+
+  if (numbers.length === 0) return Infinity;
+  return Math.max(...numbers);
+}