@ledgerhq/live-common 21.21.2 → 21.22.1

package/src/families/tezos/test-dataset.ts

@@ -1,431 +1,101 @@
-import invariant from "invariant";
-import {
-  NotEnoughBalance,
-  NotEnoughBalanceInParentAccount,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  RecommendUndelegation,
-  NotSupportedLegacyAddress,
-} from "@ledgerhq/errors";
-import { BigNumber } from "bignumber.js";
-import { fromTransactionRaw } from "./transaction";
 import type { DatasetTest } from "../../types";
 import type { Transaction } from "./types";
-import tezosScanAccounts1 from "./datasets/tezos.scanAccounts.1";
+
+// TODO restore
+// import tezosScanAccounts1 from "./datasets/tezos.scanAccounts.1";
+
+// FIXME these accounts no longer reflect their expected states..
 export const accountTZrevealedDelegating = makeAccount(
   "TZrevealedDelegating",
-  "02389ffd73423626894cb151416e51c72ec285376673daf83545eb5edb45b261ce",
+  "tz1boBHAVpwcvKkNFAQHYr7mjxAz1PpVgKq7",
   "tezbox"
 );
+/*
 const accountTZwithKT = makeAccount(
   "TZwithKT",
-  "0294e8344ae6df2d3123fa100b5abd40cee339c67838b1c34c4f243cc582f4d2d8",
+  "tz1T72nyqnJWwxad6RQnh7imKQz7mzToamWd",
   "tezbox"
 );
+*/
 const accountTZnew = makeAccount(
   "TZnew",
-  "02a9ae8b0ff5f9a43565793ad78e10db6f12177d904d208ada591b8a5b9999e3fd",
+  "tz1VSichevvJSNkSSntgwKDKikWNB6iqNJii",
   "tezbox"
 );
 const accountTZnotRevealed = makeAccount(
   "TZnotRevealed",
-  "020162dc75ad3c2b6e097d15a1513033c60d8a033f2312ff5a6ead812228d9d653",
+  "tz1PWFt4Ym6HedY78MgUP2kVDtSampGwprs5",
   "tezosbip44h"
 );
 const accountTZRevealedNoDelegate = makeAccount(
   "TZRevealedNoDelegate",
-  "029bfe70b3e94ff23623f6c42f6e081a9ca8cc78f74b0d8da58f0d4cdc41c33c1a",
+  "tz1YkAjh5mm5gJ5u3VbFLEtpAG7cFo7PfCux",
   "tezosbip44h"
 );
+/*
 const accountTZemptyWithKT = makeAccount(
   "TZemptyWithKT",
-  "020c38103f932f446dc4c09ac946e9643386609453e77716d3df45f1149aa52072",
+  "tz1TeawWFnUmeP1qQLf4JWe5D7LaNp1qxgMW",
   "tezbox"
 );
-const addressAccountTZrevealedDelegating =
-  "tz1boBHAVpwcvKkNFAQHYr7mjxAz1PpVgKq7";
-const addressTZregular = "tz1T72nyqnJWwxad6RQnh7imKQz7mzToamWd";
-const addressTZnew = "tz1VSichevvJSNkSSntgwKDKikWNB6iqNJii";
-const addressKT = "KT1V99vDN5DHNpU9swVXg1cAT2ji981cccXC";
-const addressDelegator = "tz1WCd2jm4uSt4vntk4vSuUWoZQGhLcDuR9q";
-
-const reservedAmountForStorageLimit = (storageLimit) =>
-  new BigNumber(storageLimit || 0).times("1000");
+*/
 
 const dataset: DatasetTest<Transaction> = {
-  implementations: ["libcore"],
-  // @ts-expect-error we disable the test by giving an empty object
-  currencies: {} || {
+  implementations: ["js"],
+  currencies: {
     tezos: {
       FIXME_ignoreOperationFields: ["blockHeight"],
-      scanAccounts: [tezosScanAccounts1],
+      // scanAccounts: [tezosScanAccounts1],
+      scanAccounts: [],
       accounts: [
         {
-          FIXME_tests: [
-            "balance is sum of ops", // https://ledgerhq.atlassian.net/browse/LLC-591
-          ],
           raw: accountTZrevealedDelegating,
-          transactions: [
-            {
-              name: "send max to new account (explicit)",
-              transaction: fromTransactionRaw({
-                amount: "0",
-                recipient: addressTZnew,
-                useAllAmount: true,
-                family: "tezos",
-                mode: "send",
-                networkInfo: {
-                  family: "tezos",
-                  fees: "3075",
-                },
-                fees: "3075",
-                gasLimit: "10600",
-                storageLimit: "300",
-                taquitoError: null,
-              }),
-              expectedStatus: (account) => ({
-                errors: {},
-                warnings: {
-                  amount: new RecommendUndelegation(),
-                },
-                estimatedFees: new BigNumber("3075"),
-                amount: account.balance
-                  .minus(reservedAmountForStorageLimit("300"))
-                  .minus("3075"),
-                totalSpent: account.balance,
-              }),
-            },
-            {
-              name: "overflow send to new account",
-              transaction: (t, account) => ({
-                ...t,
-                amount: account.balance.minus(t.fees || 0).minus("1000"),
-                recipient: addressTZnew,
-              }),
-              expectedStatus: {
-                errors: {
-                  amount: new NotEnoughBalance(),
-                },
-                warnings: {},
-              },
-            },
-            {
-              name: "send max to new account (dynamic)",
-              transaction: (t) => ({
-                ...t,
-                recipient: addressTZnew,
-                useAllAmount: true,
-              }),
-              expectedStatus: (account, { storageLimit, fees }) => (
-                invariant(fees, "fees are required"),
-                {
-                  errors: {},
-                  warnings: {
-                    amount: new RecommendUndelegation(),
-                  },
-                  estimatedFees: fees,
-                  amount: account.balance
-                    .minus(reservedAmountForStorageLimit(storageLimit))
-                    .minus(fees as BigNumber),
-                  totalSpent: account.balance,
-                }
-              ),
-            },
-            {
-              name: "send max to existing account",
-              transaction: (t) => ({
-                ...t,
-                recipient: addressTZregular,
-                useAllAmount: true,
-              }),
-              expectedStatus: (account, { fees }) => (
-                invariant(fees, "fees are required"),
-                {
-                  errors: {},
-                  warnings: {
-                    amount: new RecommendUndelegation(),
-                  },
-                  estimatedFees: fees,
-                  amount: account.balance.minus(fees as BigNumber),
-                  totalSpent: account.balance,
-                }
-              ),
-            },
-            {
-              name: "self tx forbidden",
-              transaction: (t) => ({
-                ...t,
-                recipient: addressAccountTZrevealedDelegating,
-                amount: new BigNumber(0.1),
-              }),
-              expectedStatus: {
-                errors: {
-                  recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
-                },
-                warnings: {},
-              },
-            },
-            {
-              name: "undelegate",
-              transaction: (t) => ({ ...t, mode: "undelegate" }),
-              expectedStatus: (account, { fees }) => (
-                invariant(fees, "fees are required"),
-                {
-                  errors: {},
-                  warnings: {},
-                  amount: new BigNumber(0),
-                  estimatedFees: fees,
-                }
-              ),
-            },
-          ],
+          transactions: [],
         },
         {
-          FIXME_tests: [
-            "balance is sum of ops", // https://ledgerhq.atlassian.net/browse/LLC-591
-          ],
           raw: accountTZRevealedNoDelegate,
-          transactions: [
-            {
-              name: "send max to new account",
-              transaction: (t) => ({
-                ...t,
-                recipient: addressTZnew,
-                useAllAmount: true,
-              }),
-              expectedStatus: (account, { storageLimit, fees }) => (
-                invariant(fees, "fees are required"),
-                {
-                  errors: {},
-                  warnings: {},
-                  estimatedFees: fees,
-                  amount: account.balance
-                    .minus(reservedAmountForStorageLimit(storageLimit))
-                    .minus(fees as BigNumber),
-                  totalSpent: account.balance,
-                }
-              ),
-            },
-            {
-              name: "send max to existing account",
-              transaction: (t) => ({
-                ...t,
-                recipient: addressTZregular,
-                useAllAmount: true,
-              }),
-              expectedStatus: (account, { fees }) => (
-                invariant(fees, "fees are required"),
-                {
-                  errors: {},
-                  warnings: {},
-                  estimatedFees: fees,
-                  amount: account.balance.minus(fees as BigNumber),
-                  totalSpent: account.balance,
-                }
-              ),
-            },
-            {
-              name: "delegate",
-              transaction: (t) => ({
-                ...t,
-                recipient: addressDelegator,
-                mode: "delegate",
-              }),
-              expectedStatus: (account, { fees }) => (
-                invariant(fees, "fees are required"),
-                {
-                  errors: {},
-                  warnings: {},
-                  amount: new BigNumber(0),
-                  estimatedFees: fees,
-                }
-              ),
-            },
-          ],
+          transactions: [],
         },
         {
           raw: accountTZnotRevealed,
-          FIXME_tests: [
-            "balance is sum of ops", // https://ledgerhq.atlassian.net/browse/LLC-591
-          ],
-          transactions: [
-            {
-              name: "send 10% to KT",
-              transaction: (t, account) => ({
-                ...t,
-                recipient: addressKT,
-                amount: account.balance.div(10),
-              }),
-              expectedStatus: {
-                errors: {
-                  recipient: new NotSupportedLegacyAddress(),
-                },
-                warnings: {},
-              },
-            },
-            {
-              name: "send 10% to existing tz",
-              transaction: (t, account) => ({
-                ...t,
-                recipient: addressTZnew,
-                amount: account.balance.div(10),
-              }),
-              expectedStatus: (account, { fees }) => (
-                invariant(fees, "fees are required"),
-                {
-                  errors: {},
-                  warnings: {},
-                  estimatedFees: (fees as BigNumber).times(2),
-                  amount: account.balance.div(10),
-                  totalSpent: account.balance
-                    .div(10)
-                    .plus((fees as BigNumber).times(2)),
-                }
-              ),
-            },
-          ],
+          transactions: [],
         },
         {
           raw: accountTZnew,
           test: (expect, account) => {
             expect(account.operations).toEqual([]);
           },
-          transactions: [
-            {
-              name: "send 10% to existing tz",
-              transaction: (t) => ({
-                ...t,
-                recipient: addressTZregular,
-                useAllAmount: true,
-              }),
-              expectedStatus: {
-                errors: {
-                  amount: new NotEnoughBalance(),
-                },
-                warnings: {},
-              },
-            },
-          ],
+          transactions: [],
         },
+        // FIXME these accounts have issue
+        /*
         {
-          FIXME_tests: [
-            "balance is sum of ops", // https://ledgerhq.atlassian.net/browse/LLC-503
-            // because of prev bug we have bug on:
-            "from KT 2, send max to existing account",
-          ],
           raw: accountTZwithKT,
           transactions: [
-            {
-              name: "from KT 1, send max to new account",
-              transaction: (t, account) => (
-                invariant(account.subAccounts, "subAccounts"),
-                {
-                  ...t,
-                  subAccountId: account.subAccounts?.[0].id,
-                  recipient: addressTZnew,
-                  useAllAmount: true,
-                }
-              ),
-              expectedStatus: ({ subAccounts }, { storageLimit, fees }) => (
-                invariant(fees && subAccounts, "fees are required"),
-                {
-                  errors: {},
-                  warnings: {},
-                  estimatedFees: fees,
-                  amount: subAccounts?.[0].balance.minus(
-                    reservedAmountForStorageLimit(storageLimit)
-                  ),
-                  totalSpent: subAccounts?.[0].balance,
-                }
-              ),
-            },
-            {
-              name: "from KT 2, send max to existing account",
-              transaction: (t, account) => (
-                invariant(
-                  account.subAccounts && account.subAccounts[1],
-                  "subAccounts"
-                ),
-                {
-                  ...t,
-                  subAccountId: account.subAccounts?.[1].id,
-                  recipient: addressTZnew,
-                  useAllAmount: true,
-                }
-              ),
-              expectedStatus: ({ subAccounts }, { fees, storageLimit }) => (
-                invariant(
-                  subAccounts && fees && storageLimit,
-                  "fees are required"
-                ),
-                {
-                  errors: {},
-                  warnings: {},
-                  estimatedFees: fees,
-                  amount: subAccounts?.[1].balance,
-                  totalSpent: subAccounts?.[1].balance,
-                }
-              ),
-            },
           ],
         },
+        */
+        /*
         {
-          FIXME_tests: [
-            "balance is sum of ops", // https://ledgerhq.atlassian.net/browse/LLC-591
-          ],
           raw: accountTZemptyWithKT,
           transactions: [
-            {
-              name: "from KT 1, send max",
-              transaction: (t, account) => (
-                invariant(account.subAccounts, "subAccounts"),
-                {
-                  ...t,
-                  subAccountId: account.subAccounts?.[0].id,
-                  recipient: addressTZregular,
-                  useAllAmount: true,
-                }
-              ),
-              expectedStatus: {
-                errors: {
-                  amount: new NotEnoughBalanceInParentAccount(),
-                },
-                warnings: {},
-              },
-            },
-            {
-              name: "from KT 1, send 10%",
-              transaction: (t, account) => (
-                invariant(account.subAccounts, "subAccounts"),
-                {
-                  ...t,
-                  subAccountId: account.subAccounts?.[0].id,
-                  amount: account.balance.div(10),
-                  recipient: addressTZregular,
-                }
-              ),
-              expectedStatus: {
-                errors: {
-                  amount: new NotEnoughBalanceInParentAccount(),
-                },
-                warnings: {},
-              },
-            },
           ],
         },
+        */
       ],
     },
   },
 };
 export default dataset;
 
-function makeAccount(name, pubKey, derivationMode) {
+function makeAccount(name, address, derivationMode) {
   return {
-    id: `libcore:1:tezos:${pubKey}:${derivationMode}`,
-    seedIdentifier: pubKey,
+    id: `js:2:tezos:${address}:${derivationMode}`,
+    seedIdentifier: address,
     name: "Tezos " + name,
     derivationMode,
     index: 0,
-    freshAddress: "",
+    freshAddress: address,
     freshAddressPath: "",
     freshAddresses: [],
     blockHeight: 0,
@@ -435,7 +105,7 @@ function makeAccount(name, pubKey, derivationMode) {
     unitMagnitude: 6,
     lastSyncDate: "",
     balance: "0",
-    xpub: pubKey,
+    xpub: "",
     subAccounts: [],
   };
 }

package/src/families/tezos/transaction.ts

@@ -17,6 +17,7 @@ export const formatTransaction = (
     storageLimit,
     fees,
     useAllAmount,
+    estimatedFees,
   }: Transaction,
   mainAccount: Account
 ): string => {
@@ -36,7 +37,10 @@ ${mode.toUpperCase()} ${
 TO ${recipient}
 with fees=${!fees ? "?" : formatCurrencyUnit(mainAccount.unit, fees)}
 with gasLimit=${!gasLimit ? "?" : gasLimit.toString()}
-with storageLimit=${!storageLimit ? "?" : storageLimit.toString()}`;
+with storageLimit=${!storageLimit ? "?" : storageLimit.toString()}
+(estimatedFees ${
+    !estimatedFees ? "?" : formatCurrencyUnit(mainAccount.unit, estimatedFees)
+  })`;
 };
 export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
   const common = fromTransactionCommonRaw(tr);
@@ -52,6 +56,7 @@ export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
     fees: tr.fees ? new BigNumber(tr.fees) : null,
     gasLimit: tr.gasLimit ? new BigNumber(tr.gasLimit) : null,
     storageLimit: tr.storageLimit ? new BigNumber(tr.storageLimit) : null,
+    estimatedFees: tr.estimatedFees ? new BigNumber(tr.estimatedFees) : null,
     taquitoError: tr.taquitoError,
   };
 };
@@ -69,6 +74,7 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
     fees: t.fees ? t.fees.toString() : null,
     gasLimit: t.gasLimit ? t.gasLimit.toString() : null,
     storageLimit: t.storageLimit ? t.storageLimit.toString() : null,
+    estimatedFees: t.estimatedFees ? t.estimatedFees.toString() : null,
     taquitoError: t.taquitoError,
   };
 };

package/src/families/tezos/types.ts

@@ -136,6 +136,7 @@ export type Transaction = TransactionCommon & {
   fees: BigNumber | null | undefined;
   gasLimit: BigNumber | null | undefined;
   storageLimit: BigNumber | null | undefined;
+  estimatedFees: BigNumber | null | undefined;
   taquitoError: string | null | undefined;
 };
 export type TransactionRaw = TransactionCommonRaw & {
@@ -145,6 +146,7 @@ export type TransactionRaw = TransactionCommonRaw & {
   fees: string | null | undefined;
   gasLimit: string | null | undefined;
   storageLimit: string | null | undefined;
+  estimatedFees: string | null | undefined;
   taquitoError: string | null | undefined;
 };
 export const reflect = (declare: (arg0: string, arg1: Spec) => void) => {