@ledgerhq/live-common 21.21.4 → 21.22.0

package/src/apps/polyfill.ts

@@ -52,6 +52,7 @@ export const whitelistDependencies = ["Decred", "Decred Testnet"];
   ["RocketPool", "Ethereum"],
   ["POAP", "Ethereum"],
   ["OlympusDAO", "Ethereum"],
+  ["Rarible", "Ethereum"],
 ].forEach(([name, dep]) => declareDep(name, dep));
 export const getDependencies = (appName: string): string[] =>
   directDep[appName] || [];

package/src/bot/engine.ts

@@ -678,7 +678,7 @@ function transactionTest<T>({
   const dt = Date.now().valueOf() - operation.date.valueOf();
   invariant(dt > 0, "operation.date must not be in in future");
   expect(dt).toBeLessThan(timingThreshold);
-  invariant(!operation.hasFailed, "operation must be hasFailed");
+  invariant(!operation.hasFailed, "operation has failed");
   const { blockAvgTime } = account.currency;
 
   if (blockAvgTime && account.blockHeight) {

package/src/bot/specs.ts

@@ -6,6 +6,9 @@ import sample from "lodash/sample";
 import { isAccountEmpty } from "../account";
 import type { DeviceAction, DeviceActionArg } from "./types";
 import type { Account, Transaction } from "../types";
+
+const stepValueTransformDefault = (s) => s.trim();
+
 // TODO should weight the choice to favorize accounts with small amounts
 export function pickSiblings(siblings: Account[], maxAccount = 5): Account {
   const withoutEmpties = siblings.filter((a) => a.used);
@@ -37,6 +40,7 @@ type State<T extends Transaction> = {
 };
 type Step<T extends Transaction> = {
   title: string;
+  stepValueTransform?: (string) => string;
   expectedValue?: (
     arg0: DeviceActionArg<T, State<T>>,
     acc: Array<{
@@ -79,10 +83,12 @@ export function deviceActionFlow<T extends Transaction>(
         // there were accumulated text and we are on new step, we need to release it and compare to expected
         if (currentStep && currentStep.expectedValue) {
           const { expectedValue, ignoreAssertionFailure } = currentStep;
+          const stepValueTransform =
+            currentStep.stepValueTransform || stepValueTransformDefault;
 
           if (!ignoreAssertionFailure) {
             expect({
-              [stepTitle]: stepValue.trim(),
+              [stepTitle]: stepValueTransform(stepValue),
             }).toMatchObject({
               [stepTitle]: expectedValue(arg, acc).trim(),
             });

package/src/env.ts

@@ -111,7 +111,7 @@ const envDefinitions = {
     desc: "Ledger explorer API for tezos",
   },
   API_TEZOS_TZKT_API: {
-    def: "http://xtz-tzkt-explorer.api-01.live.ledger-stg.com",
+    def: "https://xtz-tzkt-explorer.api.live.ledger.com",
     parser: stringParser,
     desc: "tzkt.io explorer",
   },

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

@@ -6,7 +6,6 @@ import {
   NotEnoughBalance,
   NotEnoughBalanceToDelegate,
   FeeTooHigh,
-  NotSupportedLegacyAddress,
   InvalidAddressBecauseDestinationIsAlsoSource,
   RecommendUndelegation,
 } from "@ledgerhq/errors";
@@ -45,6 +44,7 @@ const createTransaction: () => Transaction = () => ({
   networkInfo: null,
   useAllAmount: false,
   taquitoError: null,
+  estimatedFees: null,
 });
 
 const updateTransaction = (t, patch) => ({ ...t, ...patch });
@@ -65,7 +65,7 @@ const getTransactionStatus = async (
     recipient?: Error;
   } = {};
 
-  let estimatedFees = new BigNumber(t.fees || 0);
+  const estimatedFees = t.estimatedFees || new BigNumber(0);
 
   const { tezosResources } = account;
   if (!tezosResources) throw new Error("tezosResources is missing");
@@ -90,17 +90,6 @@ const getTransactionStatus = async (
       }
     }
 
-    if (t.recipient.startsWith("KT") && !errors.recipient) {
-      errors.recipient = new NotSupportedLegacyAddress();
-    }
-
-    // no fee / not enough balance already handled by taquitoError
-    if (!tezosResources.revealed) {
-      // FIXME
-      // https://github.com/ecadlabs/taquito/commit/48a11cfaffe4c6bdfa6f04ebbd0b756f4b135865#diff-3b138622526cbaa55605b79011aa411652367136a3e92e43faecc654da3854e7
-      estimatedFees = estimatedFees.plus(374 || DEFAULT_FEE.REVEAL);
-    }
-
     if (t.mode === "send") {
       if (!errors.amount && t.amount.eq(0)) {
         errors.amount = new AmountRequired();
@@ -128,15 +117,22 @@ const getTransactionStatus = async (
     log("taquitoerror", String(t.taquitoError));
 
     // remap taquito errors
-    if (t.taquitoError === "proto.010-PtGRANAD.contract.balance_too_low") {
+    if (t.taquitoError.endsWith("balance_too_low")) {
       if (t.mode === "send") {
         errors.amount = new NotEnoughBalance();
       } else {
         errors.amount = new NotEnoughBalanceToDelegate();
       }
+    } else {
+      // unidentified error case
+      errors.amount = new Error(t.taquitoError);
     }
   }
 
+  if (!errors.amount && account.balance.lte(0)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
   const result = {
     errors,
     warnings,
@@ -154,8 +150,25 @@ const prepareTransaction = async (
   const { tezosResources } = account;
   if (!tezosResources) throw new Error("tezosResources is missing");
 
-  const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
+  if (account.balance.lte(0)) {
+    return Promise.resolve(transaction);
+  }
 
+  // basic check to confirm the transaction is "complete"
+  if (transaction.mode !== "undelegate") {
+    if (!transaction.recipient) {
+      return Promise.resolve(transaction);
+    }
+    const { recipientError } = await validateRecipient(
+      account.currency,
+      transaction.recipient
+    );
+    if (recipientError) {
+      return Promise.resolve(transaction);
+    }
+  }
+
+  const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
   tezos.setProvider({
     signer: {
       publicKeyHash: async () => account.freshAddress,
@@ -165,20 +178,21 @@ const prepareTransaction = async (
     },
   });
 
-  try {
-    if (transaction.useAllAmount) {
-      // taquito does not accept 0, so we do 1
-      // only failing case is when the account precisely has fees + 1. which is
-      // unlikely
-      transaction.amount = new BigNumber(1);
-    }
+  if (transaction.useAllAmount) {
+    // taquito does not accept 0, so we do 1
+    // only failing case is when the account precisely has fees + 1. which is
+    // unlikely
+    transaction.amount = new BigNumber(1);
+  }
 
+  try {
     let out;
     switch (transaction.mode) {
       case "send":
         out = await tezos.estimate.transfer({
+          mutez: true,
           to: transaction.recipient,
-          amount: transaction.amount.div(10 ** 6).toNumber(),
+          amount: transaction.amount.toNumber(),
         });
         break;
       case "delegate":
@@ -193,14 +207,15 @@ const prepareTransaction = async (
         });
         break;
       default:
-        throw "unsuported";
+        throw new Error("unsupported mode=" + transaction.mode);
     }
 
-    transaction.fees = new BigNumber(out.suggestedFeeMutez);
-    transaction.gasLimit = new BigNumber(out.gasLimit);
-    transaction.storageLimit = new BigNumber(out.storageLimit);
-
     if (transaction.useAllAmount) {
+      const totalFees = out.suggestedFeeMutez + out.burnFeeMutez;
+      const maxAmount = account.balance
+        .minus(totalFees + (tezosResources.revealed ? 0 : DEFAULT_FEE.REVEAL))
+        .toNumber();
+      // from https://github.com/ecadlabs/taquito/blob/a70c64c4b105381bb9f1d04c9c70e8ef26e9241c/integration-tests/contract-empty-implicit-account-into-new-implicit-account.spec.ts#L33
       // Temporary fix, see https://gitlab.com/tezos/tezos/-/issues/1754
       // we need to increase the gasLimit and fee returned by the estimation
       const gasBuffer = 500;
@@ -208,15 +223,37 @@ const prepareTransaction = async (
       const increasedFee = (gasBuffer: number, opSize: number) => {
         return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
       };
-      transaction.fees = transaction.fees.plus(
-        increasedFee(gasBuffer, Number(out.opSize))
+      const incr = increasedFee(gasBuffer, Number(out.opSize));
+      transaction.fees = new BigNumber(out.suggestedFeeMutez + incr);
+      transaction.gasLimit = new BigNumber(out.gasLimit + gasBuffer);
+      transaction.amount = new BigNumber(maxAmount - incr);
+    } else {
+      transaction.fees = new BigNumber(out.suggestedFeeMutez);
+      transaction.gasLimit = new BigNumber(out.gasLimit);
+      transaction.storageLimit = new BigNumber(out.storageLimit);
+    }
+
+    transaction.storageLimit = new BigNumber(out.storageLimit);
+    transaction.estimatedFees = transaction.fees;
+    if (!tezosResources.revealed) {
+      transaction.estimatedFees = transaction.estimatedFees.plus(
+        DEFAULT_FEE.REVEAL
+      );
+    }
+  } catch (e) {
+    if (typeof e !== "object" || !e) throw e;
+    if ("id" in e) {
+      transaction.taquitoError = (e as { id: string }).id;
+    } else if ("status" in e) {
+      // in case of http 400, log & ignore (more case to handle)
+      log(
+        "taquito-network-error",
+        String((e as { message: string }).message || ""),
+        { transaction }
       );
-      transaction.gasLimit = transaction.gasLimit.plus(gasBuffer);
-      const s = await getTransactionStatus(account, transaction);
-      transaction.amount = account.balance.minus(s.estimatedFees);
+    } else {
+      throw e;
     }
-  } catch (e: any) {
-    transaction.taquitoError = e.id;
   }
 
   return transaction;

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

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

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,
     };
   };