@ledgerhq/live-common 21.21.3 → 21.23.0

package/src/families/tezos/bridge/mock.ts

@@ -64,6 +64,7 @@ const createTransaction = (): Transaction => ({
   networkInfo: null,
   useAllAmount: false,
   taquitoError: null,
+  estimatedFees: null,
 });
 
 const updateTransaction = (t, patch) => ({ ...t, ...patch });

package/src/families/tezos/signOperation.ts

@@ -38,40 +38,51 @@ export const signOperation = ({
         );
         tezos.setProvider({ signer: ledgerSigner });
 
+        // disable the broadcast because we want to do it in a second phase (broadcast hook)
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
-        tezos.contract.context.injector.inject = async () => ""; // disable broadcast
+        tezos.contract.context.injector.inject = async () => "";
 
         o.next({ type: "device-signature-requested" });
 
+        let type = "OUT";
+
         let res, signature, opbytes;
+        const params = {
+          fee: transaction.fees?.toNumber() || 0,
+          storageLimit: transaction.storageLimit?.toNumber() || 0,
+          gasLimit: transaction.gasLimit?.toNumber() || 0,
+        };
         switch (transaction.mode) {
           case "send":
             res = await tezos.contract.transfer({
+              mutez: true,
               to: transaction.recipient,
-              amount: transaction.amount.div(10 ** 6).toNumber(),
-              fee: transaction.fees?.toNumber() || 0,
-              storageLimit: transaction.storageLimit?.toNumber() || 0,
-              gasLimit: transaction.gasLimit?.toNumber() || 0,
+              amount: transaction.amount.toNumber(),
+              ...params,
             });
             signature = res.raw.opOb.signature;
             opbytes = res.raw.opbytes;
             break;
           case "delegate":
             res = await tezos.contract.setDelegate({
+              ...params,
               source: freshAddress,
               delegate: transaction.recipient,
             });
             opbytes = res.raw.opbytes;
+            type = "DELEGATE";
             break;
           case "undelegate":
             res = await tezos.contract.setDelegate({
+              ...params,
               source: freshAddress,
             });
             opbytes = res.raw.opbytes;
+            type = "UNDELEGATE";
             break;
           default:
-            throw "not supported";
+            throw new Error("not supported");
         }
 
         if (cancelled) {
@@ -88,9 +99,9 @@ export const signOperation = ({
 
         // currently, all mode are always at least one OUT tx on ETH parent
         const operation = {
-          id: `${accountId}-${txHash}-OUT`,
+          id: `${accountId}-${txHash}-${type}`,
           hash: txHash,
-          type: "OUT",
+          type,
           value: transaction.amount,
           fee: fees,
           extra: {

package/src/families/tezos/specs.ts

@@ -6,7 +6,7 @@ import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
 import { pickSiblings } from "../../bot/specs";
 import type { AppSpec } from "../../bot/types";
 import { DeviceModelId } from "@ledgerhq/devices";
-import { getAccountDelegationSync } from "./bakers";
+import { getAccountDelegationSync, isAccountDelegating } from "./bakers";
 import whitelist from "./bakers.whitelist-default";
 
 const maxAccount = 12;
@@ -31,10 +31,11 @@ const tezos: AppSpec<Transaction> = {
     model: DeviceModelId.nanoS,
     appName: "TezosWallet",
   },
+  testTimeout: 2 * 60 * 1000,
   transactionCheck: ({ maxSpendable }) => {
     invariant(
       maxSpendable.gt(
-        parseCurrencyUnit(getCryptoCurrencyById("tezos").units[0], "0.1")
+        parseCurrencyUnit(getCryptoCurrencyById("tezos").units[0], "0.02")
       ),
       "balance is too low"
     );
@@ -69,9 +70,13 @@ const tezos: AppSpec<Transaction> = {
       },
     },
     {
-      name: "send max",
+      name: "send max (non delegating)",
       maxRun: 3,
       transaction: ({ account, siblings, bridge }) => {
+        invariant(
+          !isAccountDelegating(account),
+          "account must not be delegating"
+        );
         const sibling = pickSiblings(siblings, maxAccount);
         const recipient = sibling.freshAddress;
         return {
@@ -85,7 +90,10 @@ const tezos: AppSpec<Transaction> = {
       maxRun: 1,
       transaction: ({ account, bridge }) => {
         expectUnrevealed(account);
-        const recipient = sample(whitelist);
+        const d = getAccountDelegationSync(account);
+        const recipient = sample(
+          d ? whitelist.filter((w) => w !== d.address) : whitelist
+        );
         return {
           transaction: bridge.createTransaction(account),
           updates: [{ recipient, mode: "delegate" }],
@@ -97,7 +105,10 @@ const tezos: AppSpec<Transaction> = {
       maxRun: 1,
       transaction: ({ account, bridge }) => {
         expectRevealed(account);
-        const recipient = sample(whitelist);
+        const d = getAccountDelegationSync(account);
+        const recipient = sample(
+          d ? whitelist.filter((w) => w !== d.address) : whitelist
+        );
         return {
           transaction: bridge.createTransaction(account),
           updates: [{ recipient, mode: "delegate" }],

package/src/families/tezos/speculos-deviceActions.ts

@@ -15,13 +15,13 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
       button: "Rr",
     },
     {
+      title: "Custom Delegate",
+      button: "Rr",
+    },
+    {
+      // device sometimes know the text of a given delegator, we're not validating the actual text
       title: "Delegate",
       button: "Rr",
-      expectedValue: ({ transaction }) => {
-        return transaction.mode === "undelegate"
-          ? "None"
-          : transaction.recipient;
-      },
     },
     {
       title: "Delegate Name",

package/src/families/tezos/synchronisation.test.ts

@@ -9,8 +9,6 @@ import { makeSync } from "../../bridge/jsHelpers";
 import { getAccountShape } from "./synchronisation";
 
 const accounts = [
-  //  "tz1cf8diKsP1WoeucTQm1BcVfdyrmaBnL4nC", // FIXME
-  //   "tz1ZshTmtorFVkcZ7CpceCAxCn7HBJqTfmpk", // FIXME
   "tz1ZL36Xw6LJ9RK6tb7QW85o7SVYfFKSMw8c",
   "tz1VacAyLcnHU3pEY3VNNK45F1CvVyTYXA3z",
   "tz1hpWkvAVVgftPy4CW8rD3u6tdVd8g1RU58",
@@ -24,7 +22,6 @@ const accounts = [
   "tz1PTxfn1fge2tJwGGpW9zNuYf6BseM3GJXt",
   "tz1SBHto1BasGvxojr48r5PFiGb1Wq4cynGY",
   "tz1fAfYNSkgci3ko2xikDtYtcSf1X1YdAKoK",
-  "tz1hobi4RsAeswm9JA7mHB96vqc1eAWRzxDc",
 ];
 
 jest.setTimeout(30 * 1000);

package/src/families/tezos/synchronisation.ts

@@ -75,6 +75,11 @@ export const getAccountShape: GetAccountShape = async (infoInput) => {
       id: accountId,
       blockHeight,
       lastSyncDate: new Date(),
+      tezosResources: {
+        revealed: false,
+        counter: 0,
+        publicKey: "",
+      },
     };
   }
   invariant(
@@ -232,9 +237,7 @@ const txToOp =
       blockHash,
       accountId,
       date: new Date(timestamp),
-      extra: {
-        id,
-      },
+      extra: { id },
       hasFailed,
     };
   };

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: [],
   };
 }