@ledgerhq/coin-tron 0.0.1

package/src/test/bot-specs.ts

@@ -0,0 +1,457 @@
+import { BigNumber } from "bignumber.js";
+import invariant from "invariant";
+import expect from "expect";
+import type { Transaction } from "../types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec, TransactionDestinationTestInput } from "@ledgerhq/coin-framework/bot/types";
+// import { getUnfreezeData, getNextRewardDate } from "./react";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { acceptTransaction } from "./bot-deviceActions";
+const currency = getCryptoCurrencyById("tron");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "1");
+const maxAccount = 10;
+
+/*const getDecimalPart = (value: BigNumber, magnitude: number) =>
+  value.minus(value.modulo(10 ** magnitude));*/
+
+// FIXME TRON have a bug where the amounts from the API have imprecisions
+const expectedApproximate = (value: BigNumber, expected: BigNumber, delta = 50) => {
+  if (value.minus(expected).abs().gt(delta)) {
+    expect(value.toString()).toEqual(value.toString());
+  }
+};
+
+const testDestination = <T>({
+  destination,
+  operation,
+  destinationBeforeTransaction,
+  sendingOperation,
+}: TransactionDestinationTestInput<T>): void => {
+  const amount = sendingOperation.value.minus(sendingOperation.fee);
+  botTest("account balance increased with transaction amount", () =>
+    expectedApproximate(destination.balance, destinationBeforeTransaction.balance.plus(amount)),
+  );
+  botTest("operation amount is consistent with sendingOperation", () =>
+    expectedApproximate(operation.value, amount),
+  );
+};
+
+const tron: AppSpec<Transaction> = {
+  name: "Tron",
+  currency,
+  appQuery: {
+    model: DeviceModelId.nanoSP,
+    appName: "Tron",
+    firmware: "1.1.1",
+    appVersion: "0.5.0",
+  },
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 2 * 60 * 1000,
+  minViableAmount: minimalAmount,
+  mutations: [
+    {
+      name: "move 50% to another account",
+      maxRun: 2,
+      testDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        const amount = maxSpendable.div(2).integerValue();
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient,
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+      test: ({ accountBeforeTransaction, operation, account }) => {
+        botTest("account spendable balance decreased with operation", () =>
+          expectedApproximate(
+            account.spendableBalance,
+            accountBeforeTransaction.spendableBalance.minus(operation.value),
+          ),
+        );
+      },
+    },
+    {
+      name: "send max to another account",
+      maxRun: 1,
+      testDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient,
+            },
+            {
+              useAllAmount: true,
+            },
+          ],
+        };
+      },
+      test: ({ account }) => {
+        botTest("account spendable balance is zero", () =>
+          expectedApproximate(account.spendableBalance, new BigNumber(0)),
+        );
+      },
+    },
+    /*
+    We do not manage staking anymore
+    {
+      name: "freeze 25% to bandwidth | energy",
+      maxRun: 1,
+      transaction: ({ siblings, account, bridge, maxSpendable }) => {
+        expectSiblingsHaveSpendablePartGreaterThan(siblings, 0.5);
+
+        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
+        let amount = getDecimalPart(
+          maxSpendable.div(4),
+          currency.units[0].magnitude,
+        ).integerValue();
+
+        if (amount.lt(minimalAmount)) {
+          amount = minimalAmount;
+        }
+
+        const energy = get(account, `tronResources.energy`, new BigNumber(0));
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "freeze",
+            },
+            {
+              resource: energy.eq(0) ? "ENERGY" : "BANDWIDTH",
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+      test: ({ account, accountBeforeTransaction, transaction }) => {
+        const resourceType = (transaction.resource || "").toLocaleLowerCase();
+        const resourceBeforeTransaction = get(
+          accountBeforeTransaction,
+          `tronResources.frozen.${resourceType}.amount`,
+          new BigNumber(0),
+        );
+        const expectedAmount = new BigNumber(transaction.amount).plus(resourceBeforeTransaction);
+        const currentRessourceAmount = get(
+          account,
+          `tronResources.frozen.${resourceType}.amount`,
+          new BigNumber(0),
+        );
+        botTest("frozen amount is accumulated in resources", () =>
+          expect(expectedAmount.toString()).toBe(currentRessourceAmount.toString()),
+        );
+      },
+    },
+    {
+      name: "unfreeze bandwith / energy",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        const TP = new BigNumber(get(account, "tronResources.tronPower", "0"));
+        invariant(TP.gt(0), "no frozen assets");
+        const { canUnfreezeBandwidth, canUnfreezeEnergy } = getUnfreezeData(account as TronAccount);
+        invariant(canUnfreezeBandwidth || canUnfreezeEnergy, "freeze period not expired yet");
+        const resourceToUnfreeze = canUnfreezeBandwidth ? "BANDWIDTH" : "ENERGY";
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "unfreeze",
+            },
+            {
+              resource: resourceToUnfreeze,
+            },
+          ],
+        };
+      },
+      test: ({ account, accountBeforeTransaction, transaction }) => {
+        const TxResource = (transaction.resource || "").toLocaleLowerCase();
+        const currentFrozen = get(account, `tronResources.frozen.${TxResource}`, undefined);
+        botTest("no current frozen", () => expect(currentFrozen).toBeUndefined());
+        const TPBeforeTx = new BigNumber(
+          get(accountBeforeTransaction, "tronResources.tronPower", 0),
+        );
+        const currentTP = new BigNumber(get(account, "tronResources.tronPower", 0));
+        const expectedTronPower = TPBeforeTx.minus(transaction.amount);
+        botTest("tron power", () => expectedApproximate(currentTP, expectedTronPower));
+      },
+    },
+    {
+      name: "submit vote",
+      maxRun: 1,
+      transaction: ({ account, bridge, preloadedData }) => {
+        const TP = new BigNumber(get(account, "tronResources.tronPower", "0"));
+        invariant(TP.gt(0), "no tron power to vote");
+        const currentTPVoted = get(account, "tronResources.votes", []).reduce(
+          (acc, curr) => acc.plus(new BigNumber(get(curr, "voteCount", 0))),
+          new BigNumber(0),
+        );
+        invariant(TP.gt(currentTPVoted), "you have no tron power left");
+        const { superRepresentatives } = preloadedData;
+        invariant(
+          superRepresentatives && superRepresentatives.length,
+          "there are no super representatives to vote for, or the list has not been loaded yet",
+        );
+        const count = 1 + Math.floor(5 * Math.random());
+        const candidates = sampleSize(superRepresentatives.slice(0, 40), count);
+        let remaining = TP;
+        const votes = candidates
+          .map(c => {
+            if (!remaining.gt(0)) return null;
+            const voteCount = remaining.eq(1)
+              ? remaining.integerValue().toNumber()
+              : remaining.times(Math.random()).integerValue().toNumber();
+            if (voteCount === 0) return null;
+            remaining = remaining.minus(voteCount);
+            return {
+              address: c.address,
+              voteCount,
+            };
+          })
+          .filter(Boolean);
+        return {
+          transaction: bridge.createTransaction(account) as Transaction,
+          updates: [
+            {
+              mode: "vote",
+            },
+            {
+              votes,
+            },
+          ] as Array<Partial<Transaction>>,
+        };
+      },
+      test: ({ account, transaction }) => {
+        const votes = sortBy(transaction.votes, ["address"]);
+        const currentVotes = sortBy(get(account, "tronResources.votes", []), ["address"]);
+        botTest("current votes", () => expect(currentVotes).toEqual(votes));
+      },
+    },*/
+
+    /**
+     * FIXME
+     *
+     * Our bad implementation of TRC10/TRC20 operations and sync make those tests impossible to
+     * work properly.
+     *
+     * To make them work we need to rework the link between Operation and SubOperations which is wrong as of now and
+     * rework our fee estimation (TRC20 do have fees which are ignored today until the next sync creates an OUT tx to represent it).
+     */
+
+    // {
+    //   name: "move some TRC10",
+    //   maxRun: 1,
+    //   transaction: ({ account, siblings, bridge }) => {
+    //     const trc10Account = sample(
+    //       (account.subAccounts || []).filter(
+    //         (a) => a.type === "TokenAccount" && a.token.tokenType === "trc10"
+    //       )
+    //     );
+    //     invariant(trc10Account, "no trc10 account");
+    //     if (!trc10Account) throw new Error("no trc10 account");
+    //     invariant(trc10Account?.balance.gt(0), "trc10 account has no balance");
+    //     const sibling = pickSiblings(siblings, maxAccount);
+    //     const recipient = sibling.freshAddress;
+    //     return {
+    //       transaction: bridge.createTransaction(account),
+    //       updates: [
+    //         {
+    //           recipient,
+    //           subAccountId: trc10Account.id,
+    //         },
+    //         Math.random() < 0.5
+    //           ? {
+    //               useAllAmount: true,
+    //             }
+    //           : {
+    //               amount: trc10Account.balance
+    //                 .times(Math.random())
+    //                 .integerValue(),
+    //             },
+    //       ],
+    //     };
+    //   },
+    //   test: ({ accountBeforeTransaction, account, transaction }) => {
+    //     invariant(accountBeforeTransaction.subAccounts, "sub accounts before");
+    //     const trc10accountBefore = (
+    //       accountBeforeTransaction.subAccounts as SubAccount[]
+    //     ).find((s) => s.id === transaction.subAccountId);
+    //     invariant(trc10accountBefore, "trc10 acc was here before");
+    //     if (!trc10accountBefore) throw new Error("no trc10before account");
+
+    //     invariant(account.subAccounts, "sub accounts");
+    //     const trc10account = (account.subAccounts as SubAccount[]).find(
+    //       (s) => s.id === transaction.subAccountId
+    //     );
+    //     invariant(trc10account, "trc10 acc is still here");
+    //     if (!trc10account) throw new Error("no trc10 account");
+
+    //     if (transaction.useAllAmount) {
+    //       botTest("trc10 balance became zero", () =>
+    //         expect(trc10account.balance.toString()).toBe("0")
+    //       );
+    //     } else {
+    //       botTest("trc10 balance decreased with operation", () =>
+    //         expect(trc10account.balance.toString()).toBe(
+    //           trc10accountBefore.balance.minus(transaction.amount).toString()
+    //         )
+    //       );
+    //     }
+    //   },
+    // },
+
+    // {
+    //   name: "move some TRC20",
+    //   maxRun: 1,
+    //   transaction: ({ account, siblings, bridge }) => {
+    //     const balance = account.spendableBalance;
+    //     const energy = get(account, "tronResources.energy", new BigNumber(0));
+    //     invariant(
+    //       energy.gt(0) || balance.gt(minimalAmount),
+    //       "trx and energy too low"
+    //     );
+    //     const trc20Account = sample(
+    //       (account.subAccounts || []).filter(
+    //         (a) => a.type === "TokenAccount" && a.token.tokenType === "trc20"
+    //       )
+    //     );
+    //     invariant(trc20Account, "no trc20 account");
+    //     invariant(trc20Account?.balance.gt(0), "trc20 account has no balance");
+    //     if (!trc20Account) throw new Error("no trc20 account");
+
+    //     const sibling = pickSiblings(siblings, maxAccount);
+    //     invariant(
+    //       sibling.balance.gt(0),
+    //       "recipient cannot receive trc20 because it has no balance"
+    //     );
+    //     const recipient = sibling.freshAddress;
+    //     return {
+    //       transaction: bridge.createTransaction(account),
+    //       updates: [
+    //         {
+    //           recipient,
+    //           subAccountId: trc20Account.id,
+    //         },
+    //         Math.random() < 0.5
+    //           ? {
+    //               useAllAmount: true,
+    //             }
+    //           : {
+    //               amount: trc20Account.balance
+    //                 .times(Math.random())
+    //                 .integerValue(),
+    //             },
+    //       ],
+    //     };
+    //   },
+    //   test: ({ accountBeforeTransaction, account, transaction }) => {
+    //     invariant(accountBeforeTransaction.subAccounts, "sub accounts before");
+    //     const trc20accountBefore = (
+    //       accountBeforeTransaction.subAccounts as SubAccount[]
+    //     ).find((s) => s.id === transaction.subAccountId);
+    //     invariant(trc20accountBefore, "trc20 acc was here before");
+    //     if (!trc20accountBefore) throw new Error("no trc20 before account");
+    //     invariant(account.subAccounts, "sub accounts");
+    //     const trc20account = (account.subAccounts as SubAccount[]).find(
+    //       (s) => s.id === transaction.subAccountId
+    //     );
+    //     invariant(trc20account, "trc20 acc is still here");
+    //     if (!trc20account) throw new Error("no trc20 account");
+
+    //     if (transaction.useAllAmount) {
+    //       botTest("trc10 balance became zero", () =>
+    //         expect(trc20account.balance.toString()).toBe("0")
+    //       );
+    //     } else {
+    //       botTest("trc10 balance decreased with operation", () =>
+    //         expect(trc20account.balance.toString()).toBe(
+    //           trc20accountBefore.balance.minus(transaction.amount).toString()
+    //         )
+    //       );
+    //     }
+
+    //     if (
+    //       get(trc20accountBefore, "tronResources.energy", new BigNumber(0)).eq(
+    //         0
+    //       )
+    //     ) {
+    //       botTest("account balance decreased", () =>
+    //         expect(account.balance.lt(accountBeforeTransaction.balance)).toBe(
+    //           true
+    //         )
+    //       );
+    //     } else {
+    //       botTest("energy decreased", () =>
+    //         expect(
+    //           get(account, "tronResources.energy", new BigNumber(0)).lt(
+    //             get(
+    //               accountBeforeTransaction,
+    //               "tronResources.energy",
+    //               new BigNumber(0)
+    //             )
+    //           )
+    //         ).toBe(true)
+    //       );
+    //       botTest("balance didn't change", () =>
+    //         expect(account.balance.eq(accountBeforeTransaction.balance)).toBe(
+    //           true
+    //         )
+    //       );
+    //     }
+    //   },
+    // },
+    /*
+    We do not manage staking anymore
+    {
+      name: "claim rewards",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        const nextRewardDate = getNextRewardDate(account as TronAccount);
+        const today = Date.now();
+        const unwithdrawnReward = new BigNumber(
+          get(account, "tronResources.unwithdrawnReward", "0"),
+        );
+        invariant(unwithdrawnReward.gt(0), "no rewards to claim");
+        invariant(
+          nextRewardDate && nextRewardDate <= today,
+          "you can't claim twice in less than 24 hours",
+        );
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "claimReward",
+            },
+          ],
+        };
+      },
+      test: ({ account }) => {
+        const rewards = new BigNumber(get(account, "tronResources.unwithdrawnReward", "0"));
+        const nextRewardDate = getNextRewardDate(account as TronAccount);
+        botTest("rewards is zero", () => expect(rewards.eq(0)).toBe(true));
+        botTest("next reward date settled", () =>
+          expect(nextRewardDate && nextRewardDate > Date.now()).toBe(true),
+        );
+      },
+    },*/
+  ],
+};
+export default {
+  tron,
+};