@ledgerhq/coin-tron 0.0.1

package/lib-es/test/bot-specs.js

@@ -0,0 +1,428 @@
+import { BigNumber } from "bignumber.js";
+import invariant from "invariant";
+import expect from "expect";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+// 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, expected, delta = 50) => {
+    if (value.minus(expected).abs().gt(delta)) {
+        expect(value.toString()).toEqual(value.toString());
+    }
+};
+const testDestination = ({ destination, operation, destinationBeforeTransaction, sendingOperation, }) => {
+    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 = {
+    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,
+};
+//# sourceMappingURL=bot-specs.js.map

package/lib-es/test/bot-specs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bot-specs.js","sourceRoot":"","sources":["../../src/test/bot-specs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,SAAS,MAAM,WAAW,CAAC;AAClC,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAE3E,gEAAgE;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,MAAM,QAAQ,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAC/C,MAAM,aAAa,GAAG,iBAAiB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAChE,MAAM,UAAU,GAAG,EAAE,CAAC;AAEtB;+CAC+C;AAE/C,yEAAyE;AACzE,MAAM,mBAAmB,GAAG,CAAC,KAAgB,EAAE,QAAmB,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE;IAChF,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1C,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IACrD,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CAAI,EAC1B,WAAW,EACX,SAAS,EACT,4BAA4B,EAC5B,gBAAgB,GACmB,EAAQ,EAAE;IAC7C,MAAM,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAClE,OAAO,CAAC,mDAAmD,EAAE,GAAG,EAAE,CAChE,mBAAmB,CAAC,WAAW,CAAC,OAAO,EAAE,4BAA4B,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAC5F,CAAC;IACF,OAAO,CAAC,sDAAsD,EAAE,GAAG,EAAE,CACnE,mBAAmB,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAC7C,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,IAAI,GAAyB;IACjC,IAAI,EAAE,MAAM;IACZ,QAAQ;IACR,QAAQ,EAAE;QACR,KAAK,EAAE,aAAa,CAAC,MAAM;QAC3B,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE,OAAO;QACjB,UAAU,EAAE,OAAO;KACpB;IACD,mBAAmB,EAAE,iBAAiB;IACtC,WAAW,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI;IAC1B,eAAe,EAAE,aAAa;IAC9B,SAAS,EAAE;QACT;YACE,IAAI,EAAE,6BAA6B;YACnC,MAAM,EAAE,CAAC;YACT,eAAe;YACf,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE;gBAC3D,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAC,CAAC;gBAChE,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;gBACnD,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC;gBACvC,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC;gBAClD,OAAO;oBACL,WAAW,EAAE,MAAM,CAAC,iBAAiB,CAAC,OAAO,CAAC;oBAC9C,OAAO,EAAE;wBACP;4BACE,SAAS;yBACV;wBACD;4BACE,MAAM;yBACP;qBACF;iBACF,CAAC;YACJ,CAAC;YACD,IAAI,EAAE,CAAC,EAAE,wBAAwB,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,EAAE;gBACzD,OAAO,CAAC,oDAAoD,EAAE,GAAG,EAAE,CACjE,mBAAmB,CACjB,OAAO,CAAC,gBAAgB,EACxB,wBAAwB,CAAC,gBAAgB,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CACjE,CACF,CAAC;YACJ,CAAC;SACF;QACD;YACE,IAAI,EAAE,6BAA6B;YACnC,MAAM,EAAE,CAAC;YACT,eAAe;YACf,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE;gBAC3D,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAC,CAAC;gBAChE,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;gBACnD,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC;gBACvC,OAAO;oBACL,WAAW,EAAE,MAAM,CAAC,iBAAiB,CAAC,OAAO,CAAC;oBAC9C,OAAO,EAAE;wBACP;4BACE,SAAS;yBACV;wBACD;4BACE,YAAY,EAAE,IAAI;yBACnB;qBACF;iBACF,CAAC;YACJ,CAAC;YACD,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;gBACpB,OAAO,CAAC,mCAAmC,EAAE,GAAG,EAAE,CAChD,mBAAmB,CAAC,OAAO,CAAC,gBAAgB,EAAE,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,CAChE,CAAC;YACJ,CAAC;SACF;QACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuII;QAEJ;;;;;;;;WAQG;QAEH,IAAI;QACJ,6BAA6B;QAC7B,eAAe;QACf,sDAAsD;QACtD,mCAAmC;QACnC,4CAA4C;QAC5C,4EAA4E;QAC5E,UAAU;QACV,SAAS;QACT,mDAAmD;QACnD,8DAA8D;QAC9D,8EAA8E;QAC9E,0DAA0D;QAC1D,8CAA8C;QAC9C,eAAe;QACf,wDAAwD;QACxD,mBAAmB;QACnB,YAAY;QACZ,uBAAuB;QACvB,2CAA2C;QAC3C,aAAa;QACb,8BAA8B;QAC9B,gBAAgB;QAChB,oCAAoC;QACpC,gBAAgB;QAChB,gBAAgB;QAChB,6CAA6C;QAC7C,wCAAwC;QACxC,mCAAmC;QACnC,iBAAiB;QACjB,WAAW;QACX,SAAS;QACT,OAAO;QACP,oEAAoE;QACpE,8EAA8E;QAC9E,mCAAmC;QACnC,6DAA6D;QAC7D,wDAAwD;QACxD,kEAAkE;QAClE,0EAA0E;QAE1E,sDAAsD;QACtD,uEAAuE;QACvE,iDAAiD;QACjD,SAAS;QACT,0DAA0D;QAC1D,8DAA8D;QAE9D,sCAAsC;QACtC,mDAAmD;QACnD,4DAA4D;QAC5D,WAAW;QACX,eAAe;QACf,gEAAgE;QAChE,wDAAwD;QACxD,4EAA4E;QAC5E,YAAY;QACZ,WAAW;QACX,QAAQ;QACR,OAAO;QACP,KAAK;QAEL,IAAI;QACJ,6BAA6B;QAC7B,eAAe;QACf,sDAAsD;QACtD,gDAAgD;QAChD,6EAA6E;QAC7E,iBAAiB;QACjB,mDAAmD;QACnD,iCAAiC;QACjC,SAAS;QACT,mCAAmC;QACnC,4CAA4C;QAC5C,4EAA4E;QAC5E,UAAU;QACV,SAAS;QACT,mDAAmD;QACnD,8EAA8E;QAC9E,8DAA8D;QAE9D,0DAA0D;QAC1D,iBAAiB;QACjB,+BAA+B;QAC/B,mEAAmE;QACnE,SAAS;QACT,8CAA8C;QAC9C,eAAe;QACf,wDAAwD;QACxD,mBAAmB;QACnB,YAAY;QACZ,uBAAuB;QACvB,2CAA2C;QAC3C,aAAa;QACb,8BAA8B;QAC9B,gBAAgB;QAChB,oCAAoC;QACpC,gBAAgB;QAChB,gBAAgB;QAChB,6CAA6C;QAC7C,wCAAwC;QACxC,mCAAmC;QACnC,iBAAiB;QACjB,WAAW;QACX,SAAS;QACT,OAAO;QACP,oEAAoE;QACpE,8EAA8E;QAC9E,mCAAmC;QACnC,6DAA6D;QAC7D,wDAAwD;QACxD,kEAAkE;QAClE,2EAA2E;QAC3E,sDAAsD;QACtD,uEAAuE;QACvE,iDAAiD;QACjD,SAAS;QACT,0DAA0D;QAC1D,8DAA8D;QAE9D,sCAAsC;QACtC,mDAAmD;QACnD,4DAA4D;QAC5D,WAAW;QACX,eAAe;QACf,gEAAgE;QAChE,wDAAwD;QACxD,4EAA4E;QAC5E,YAAY;QACZ,WAAW;QACX,QAAQ;QAER,WAAW;QACX,8EAA8E;QAC9E,YAAY;QACZ,UAAU;QACV,UAAU;QACV,mDAAmD;QACnD,6EAA6E;QAC7E,iBAAiB;QACjB,YAAY;QACZ,WAAW;QACX,eAAe;QACf,0CAA0C;QAC1C,kBAAkB;QAClB,uEAAuE;QACvE,mBAAmB;QACnB,0CAA0C;QAC1C,wCAAwC;QACxC,iCAAiC;QACjC,gBAAgB;QAChB,cAAc;QACd,uBAAuB;QACvB,WAAW;QACX,+CAA+C;QAC/C,6EAA6E;QAC7E,iBAAiB;QACjB,YAAY;QACZ,WAAW;QACX,QAAQ;QACR,OAAO;QACP,KAAK;QACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiCI;KACL;CACF,CAAC;AACF,eAAe;IACb,IAAI;CACL,CAAC"}

package/lib-es/test/bridgeDatasetTest.d.ts

@@ -0,0 +1,4 @@
+import type { DatasetTest } from "@ledgerhq/types-live";
+import type { Transaction } from "../types";
+export declare const dataset: DatasetTest<Transaction>;
+//# sourceMappingURL=bridgeDatasetTest.d.ts.map

package/lib-es/test/bridgeDatasetTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridgeDatasetTest.d.ts","sourceRoot":"","sources":["../../src/test/bridgeDatasetTest.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAA2B,WAAW,EAAgB,MAAM,sBAAsB,CAAC;AAkB/F,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,UAAU,CAAC;AAgyC5D,eAAO,MAAM,OAAO,EAAE,WAAW,CAAC,WAAW,CAK5C,CAAC"}