@ledgerhq/live-common 29.1.0 → 29.2.0-next.0

package/src/families/hedera/utils.ts

@@ -2,13 +2,25 @@ import estimateMaxSpendable from "./js-estimateMaxSpendable";
 import BigNumber from "bignumber.js";
 import type { Account } from "@ledgerhq/types-live";
 import type { Transaction } from "./types";
+import network from "../../network";
 
-// NOTE: Hedera declares stable fees in USD
-//       If we can get the current USD/HBAR price here..
-//       > transfer fee is 0.0001 USD
-export const estimatedFees = new BigNumber("83300"); // 0.000833 ℏ (as of 2021-09-20)
 export const estimatedFeeSafetyRate = 2;
 
+export async function getEstimatedFees(): Promise<BigNumber> {
+  try {
+    const { data } = await network({
+      method: "GET",
+      url: "https://countervalues.live.ledger.com/latest/direct?pairs=hbar:usd",
+    });
+
+    return new BigNumber(10000).dividedBy(data[0]);
+  } catch {
+    // as fees are based on a currency conversion, we stay
+    // on the safe side here and double the estimate for "max spendable"
+    return new BigNumber("150200").multipliedBy(estimatedFeeSafetyRate); // 0.001502 ℏ (as of 2023-03-14)
+  }
+}
+
 export async function calculateAmount({
   account,
   transaction,
@@ -25,7 +37,7 @@ export async function calculateAmount({
 
   return {
     amount,
-    totalSpent: amount.plus(estimatedFees),
+    totalSpent: amount.plus(await getEstimatedFees()),
   };
 }
 

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

@@ -13,11 +13,7 @@ import signOperation from "../js-signOperation";
 import broadcast from "../js-broadcast";
 import estimateMaxSpendable from "../js-estimateMaxSpendable";
 import { preload, hydrate, getPreloadStrategy } from "../preload";
-import {
-  assignToAccountRaw,
-  assignFromAccountRaw,
-  applyReconciliation,
-} from "../serialization";
+import { assignToAccountRaw, assignFromAccountRaw } from "../serialization";
 
 const receive = makeAccountBridgeReceive();
 
@@ -40,7 +36,6 @@ const accountBridge: AccountBridge<Transaction> = {
   broadcast,
   assignToAccountRaw,
   assignFromAccountRaw,
-  applyReconciliation,
 };
 
 export default { currencyBridge, accountBridge };

package/src/families/near/serialization.ts

@@ -1,5 +1,4 @@
 import { BigNumber } from "bignumber.js";
-import { isEqual } from "lodash";
 import type {
   NearAccount,
   NearAccountRaw,
@@ -73,27 +72,3 @@ export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
     (account as NearAccount).nearResources =
       fromNearResourcesRaw(nearResourcesRaw);
 }
-
-export function applyReconciliation(
-  account: Account,
-  updatedRaw: AccountRaw,
-  next: Account
-): boolean {
-  let changed = false;
-  const nearAcc = account as NearAccount;
-  const nearUpdatedRaw = updatedRaw as NearAccountRaw;
-  if (
-    nearUpdatedRaw.nearResources &&
-    (!nearAcc.nearResources ||
-      !isEqual(
-        toNearResourcesRaw(nearAcc.nearResources),
-        nearUpdatedRaw.nearResources
-      ))
-  ) {
-    (next as NearAccount).nearResources = fromNearResourcesRaw(
-      nearUpdatedRaw.nearResources
-    );
-    changed = true;
-  }
-  return changed;
-}

package/src/families/solana/api/chain/web3.ts

@@ -260,6 +260,17 @@ export function getStakeAccountMinimumBalanceForRentExemption(api: ChainAPI) {
   return api.getMinimumBalanceForRentExemption(StakeProgram.space);
 }
 
+export async function getAccountMinimumBalanceForRentExemption(
+  api: ChainAPI,
+  address: string
+) {
+  const accInfo = await api.getAccountInfo(address);
+  const accSpace =
+    accInfo !== null && "parsed" in accInfo.data ? accInfo.data.space : 0;
+
+  return api.getMinimumBalanceForRentExemption(accSpace);
+}
+
 export async function getStakeAccountAddressWithSeed({
   fromAddress,
   seed,

package/src/families/solana/bridge/bridge.ts

@@ -26,11 +26,7 @@ import { getAccountShapeWithAPI } from "../js-synchronization";
 import type { SolanaAccount, Transaction } from "../types";
 import { endpointByCurrencyId } from "../utils";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import {
-  assignToAccountRaw,
-  applyReconciliation,
-  assignFromAccountRaw,
-} from "../serialization";
+import { assignToAccountRaw, assignFromAccountRaw } from "../serialization";
 
 function makePrepare(getChainAPI: (config: Config) => Promise<ChainAPI>) {
   async function prepareTransaction(
@@ -178,7 +174,6 @@ export function makeBridges({
     prepareTransaction: makePrepare(getQueuedAndCachedAPI),
     broadcast: makeBroadcast(getAPI),
     signOperation: makeSign(getAPI),
-    applyReconciliation,
     assignFromAccountRaw,
     assignToAccountRaw,
   };

package/src/families/solana/bridge.integration.test.ts

@@ -32,7 +32,6 @@ import {
 import {
   encodeAccountIdWithTokenAccountAddress,
   MAX_MEMO_LENGTH,
-  SOLANA_DUST,
 } from "./logic";
 import createTransaction from "./js-createTransaction";
 import { compact } from "lodash/fp";
@@ -73,6 +72,7 @@ const testOnChainData = {
   validatorAddress: "9QU2QSxhb24FUX3Tu2FpczXjpK3VYrvRudywSZaM29mF",
   fees: {
     stakeAccountRentExempt: 2282880,
+    systemAccountRentExempt: 890880,
     lamportsPerSignature: 5000,
   },
   // ---  maybe outdated or not real, fine for tests ---
@@ -328,8 +328,12 @@ function transferTests(): TransactionTestSpec[] {
         errors: {},
         warnings: {},
         estimatedFees: fees(1),
-        amount: testOnChainData.fundedSenderBalance.minus(fees(1)),
-        totalSpent: testOnChainData.fundedSenderBalance,
+        amount: testOnChainData.fundedSenderBalance
+          .minus(fees(1))
+          .minus(testOnChainData.fees.systemAccountRentExempt),
+        totalSpent: testOnChainData.fundedSenderBalance.minus(
+          testOnChainData.fees.systemAccountRentExempt
+        ),
       },
     },
     {
@@ -758,11 +762,13 @@ function stakingTests(): TransactionTestSpec[] {
         amount: testOnChainData.fundedSenderBalance
           .minus(fees(1))
           .minus(testOnChainData.fees.stakeAccountRentExempt)
-          .minus(SOLANA_DUST),
+          .minus(testOnChainData.fees.systemAccountRentExempt),
         estimatedFees: fees(1).plus(
           testOnChainData.fees.stakeAccountRentExempt
         ),
-        totalSpent: testOnChainData.fundedSenderBalance.minus(SOLANA_DUST),
+        totalSpent: testOnChainData.fundedSenderBalance.minus(
+          testOnChainData.fees.systemAccountRentExempt
+        ),
         errors: {},
       },
     },

package/src/families/solana/js-estimateMaxSpendable.ts

@@ -2,7 +2,10 @@ import type { AccountBridge } from "@ledgerhq/types-live";
 import type { Transaction } from "./types";
 import BigNumber from "bignumber.js";
 import { ChainAPI } from "./api";
-import { getStakeAccountMinimumBalanceForRentExemption } from "./api/chain/web3";
+import {
+  getAccountMinimumBalanceForRentExemption,
+  getStakeAccountMinimumBalanceForRentExemption,
+} from "./api/chain/web3";
 import { getMainAccount } from "../../account";
 import { estimateTxFee } from "./tx-fees";
 
@@ -30,8 +33,16 @@ const estimateMaxSpendableWithAPI = async (
             0
           );
         }
-        default:
-          return BigNumber.max(account.spendableBalance.minus(txFee), 0);
+        default: {
+          const rentExemptMin = await getAccountMinimumBalanceForRentExemption(
+            api,
+            account.freshAddress
+          );
+          return BigNumber.max(
+            account.spendableBalance.minus(txFee).minus(rentExemptMin),
+            0
+          );
+        }
       }
     }
     case "TokenAccount":

package/src/families/solana/js-prepareTransaction.ts

@@ -11,6 +11,7 @@ import { findSubAccountById } from "../../account";
 import type { Account } from "@ledgerhq/types-live";
 import { ChainAPI } from "./api";
 import {
+  getAccountMinimumBalanceForRentExemption,
   getMaybeTokenAccount,
   getMaybeVoteAccount,
   getStakeAccountAddressWithSeed,
@@ -40,7 +41,6 @@ import {
   isEd25519Address,
   isValidBase58Address,
   MAX_MEMO_LENGTH,
-  SOLANA_DUST,
 } from "./logic";
 import { estimateTxFee } from "./tx-fees";
 import type {
@@ -326,8 +326,16 @@ async function deriveTransferCommandDescriptor(
 
   const fee = await estimateTxFee(api, mainAccount, "transfer");
 
+  const rentExemptMin = await getAccountMinimumBalanceForRentExemption(
+    api,
+    mainAccount.freshAddress
+  );
+
   const txAmount = tx.useAllAmount
-    ? BigNumber.max(mainAccount.spendableBalance.minus(fee), 0)
+    ? BigNumber.max(
+        mainAccount.spendableBalance.minus(fee).minus(rentExemptMin),
+        0
+      )
     : tx.amount;
 
   if (tx.useAllAmount) {
@@ -337,7 +345,9 @@ async function deriveTransferCommandDescriptor(
   } else {
     if (txAmount.lte(0)) {
       errors.amount = new AmountRequired();
-    } else if (txAmount.plus(fee).gt(mainAccount.spendableBalance)) {
+    } else if (
+      txAmount.plus(fee).plus(rentExemptMin).gt(mainAccount.spendableBalance)
+    ) {
       errors.amount = new NotEnoughBalance();
     }
   }
@@ -375,16 +385,24 @@ async function deriveStakeCreateAccountCommandDescriptor(
   const stakeAccRentExemptAmount =
     await getStakeAccountMinimumBalanceForRentExemption(api);
 
+  const rentExemptMin = await getAccountMinimumBalanceForRentExemption(
+    api,
+    mainAccount.freshAddress
+  );
+
   const fee = txFee + stakeAccRentExemptAmount;
 
   const amount = tx.useAllAmount
     ? BigNumber.max(
-        mainAccount.spendableBalance.minus(fee).minus(SOLANA_DUST),
+        mainAccount.spendableBalance.minus(fee).minus(rentExemptMin),
         0
       )
     : tx.amount;
 
-  if (!errors.amount && mainAccount.spendableBalance.lt(amount.plus(fee))) {
+  if (
+    !errors.amount &&
+    mainAccount.spendableBalance.lt(amount.plus(fee).plus(rentExemptMin))
+  ) {
     errors.amount = new NotEnoughBalance();
   }
 

package/src/families/solana/logic.ts

@@ -1,19 +1,14 @@
-import { findTokenById, getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { findTokenById } from "@ledgerhq/cryptoassets";
 import { PublicKey } from "@solana/web3.js";
 import { TokenAccount } from "@ledgerhq/types-live";
 import { StakeMeta } from "./api/chain/account/stake";
 import { SolanaStake, StakeAction } from "./types";
 import { assertUnreachable } from "./utils";
-import { parseCurrencyUnit } from "../../currencies";
-
-const currency = getCryptoCurrencyById("solana");
 
 export type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
 
 export const MAX_MEMO_LENGTH = 500;
 
-export const SOLANA_DUST = parseCurrencyUnit(currency.units[0], "0.00001");
-
 export const isValidBase58Address = (address: string): boolean => {
   try {
     return Boolean(new PublicKey(address));

package/src/families/solana/serialization.ts

@@ -5,7 +5,6 @@ import {
   SolanaResourcesRaw,
 } from "./types";
 import { Account, AccountRaw } from "@ledgerhq/types-live";
-import { isEqual } from "lodash";
 
 export function toSolanaResourcesRaw(
   resources: SolanaResources
@@ -38,28 +37,3 @@ export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
     (account as SolanaAccount).solanaResources =
       fromSolanaResourcesRaw(solanaResourcesRaw);
 }
-
-export function applyReconciliation(
-  account: Account,
-  updatedRaw: AccountRaw,
-  next: Account
-): boolean {
-  let changed = false;
-  const solanaAcc = account as SolanaAccount;
-  const solanaUpdatedRaw = updatedRaw as SolanaAccountRaw;
-
-  if (
-    solanaUpdatedRaw.solanaResources &&
-    (!solanaAcc.solanaResources ||
-      !isEqual(
-        toSolanaResourcesRaw(solanaAcc.solanaResources),
-        solanaUpdatedRaw.solanaResources
-      ))
-  ) {
-    (next as SolanaAccount).solanaResources = fromSolanaResourcesRaw(
-      solanaUpdatedRaw.solanaResources
-    );
-    changed = true;
-  }
-  return changed;
-}

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

@@ -41,11 +41,7 @@ import { patchOperationWithHash } from "../../../operation";
 import { log } from "@ledgerhq/logs";
 import { InvalidAddressBecauseAlreadyDelegated } from "../../../errors";
 import api from "../api/tzkt";
-import {
-  applyReconciliation,
-  assignFromAccountRaw,
-  assignToAccountRaw,
-} from "../serialization";
+import { assignFromAccountRaw, assignToAccountRaw } from "../serialization";
 
 const validateRecipient = (currency, recipient) => {
   let recipientError: Error | null = null;
@@ -403,7 +399,6 @@ const accountBridge: AccountBridge<Transaction> = {
   receive,
   signOperation,
   broadcast,
-  applyReconciliation,
   assignToAccountRaw,
   assignFromAccountRaw,
 };

package/src/families/tezos/serialization.ts

@@ -5,7 +5,6 @@ import type {
   TezosResourcesRaw,
 } from "./types";
 import { Account, AccountRaw } from "@ledgerhq/types-live";
-import isEqual from "lodash/isEqual";
 
 export function toTezosResourcesRaw(r: TezosResources): TezosResourcesRaw {
   const { revealed, counter } = r;
@@ -32,27 +31,3 @@ export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
     (account as TezosAccount).tezosResources =
       fromTezosResourcesRaw(tezosResourcesRaw);
 }
-
-export function applyReconciliation(
-  account: Account,
-  updatedRaw: AccountRaw,
-  next: Account
-): boolean {
-  let changed = false;
-  const tezosAcc = account as TezosAccount;
-  const tezosUpdatedRaw = updatedRaw as TezosAccountRaw;
-  if (
-    tezosUpdatedRaw.tezosResources &&
-    (!tezosAcc.tezosResources ||
-      !isEqual(
-        toTezosResourcesRaw(tezosAcc.tezosResources),
-        tezosUpdatedRaw.tezosResources
-      ))
-  ) {
-    (next as TezosAccount).tezosResources = fromTezosResourcesRaw(
-      tezosUpdatedRaw.tezosResources
-    );
-    changed = true;
-  }
-  return changed;
-}

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

@@ -86,11 +86,7 @@ import {
 import { activationFees, oneTrx } from "../constants";
 import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
 import type { AccountShapeInfo } from "../../../bridge/jsHelpers";
-import {
-  assignFromAccountRaw,
-  assignToAccountRaw,
-  applyReconciliation,
-} from "../serialization";
+import { assignFromAccountRaw, assignToAccountRaw } from "../serialization";
 
 const receive = makeAccountBridgeReceive();
 
@@ -849,7 +845,6 @@ const accountBridge: AccountBridge<Transaction> = {
   receive,
   signOperation,
   broadcast,
-  applyReconciliation,
   assignFromAccountRaw,
   assignToAccountRaw,
 };

package/src/families/tron/serialization.ts

@@ -1,5 +1,4 @@
 import { BigNumber } from "bignumber.js";
-import { isEqual } from "lodash";
 import type {
   TronAccount,
   TronAccountRaw,
@@ -171,27 +170,3 @@ export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
     (account as TronAccount).tronResources =
       fromTronResourcesRaw(tronResourcesRaw);
 }
-
-export function applyReconciliation(
-  account: Account,
-  updatedRaw: AccountRaw,
-  next: Account
-): boolean {
-  let changed = false;
-  const tronAcc = account as TronAccount;
-  const tronUpdatedRaw = updatedRaw as TronAccountRaw;
-  if (
-    tronUpdatedRaw.tronResources &&
-    (!tronAcc.tronResources ||
-      !isEqual(
-        toTronResourcesRaw(tronAcc.tronResources),
-        tronUpdatedRaw.tronResources
-      ))
-  ) {
-    (next as TronAccount).tronResources = fromTronResourcesRaw(
-      tronUpdatedRaw.tronResources
-    );
-    changed = true;
-  }
-  return changed;
-}

package/src/hw/deviceAccess.ts

@@ -106,6 +106,7 @@ export const withDevice =
 
       // When we'll finish all the current job, we'll call finish
       let resolveQueuedDevice;
+
       // This new promise is the next exec queue
       deviceQueues[deviceId] = new Promise((resolve) => {
         resolveQueuedDevice = resolve;
@@ -118,12 +119,14 @@ export const withDevice =
       deviceQueue
         .then(() => open(deviceId)) // open the transport
         .then(async (transport) => {
-          log("withDevice", `${nonce}: Starting job`);
-          setAllowAutoDisconnect(transport, deviceId, false);
+          log("withDevice", `${nonce}: got a transport`);
+
           if (unsubscribed) {
+            log("withDevice", `${nonce}: but we're unsubscribed`);
             // It was unsubscribed prematurely
             return finalize(transport, [resolveQueuedDevice]);
           }
+          setAllowAutoDisconnect(transport, deviceId, false);
 
           if (needsCleanup[identifyTransport(transport)]) {
             delete needsCleanup[identifyTransport(transport)];
@@ -149,6 +152,7 @@ export const withDevice =
             return finalize(transport, [resolveQueuedDevice]);
           }
 
+          log("withDevice", `${nonce}: Starting job`);
           sub = job(transport)
             .pipe(
               catchError(initialErrorRemapping),

package/src/hw/extractOnboardingState.test.ts

@@ -1,3 +1,4 @@
+import { DeviceExtractOnboardingStateError } from "@ledgerhq/errors";
 import {
   extractOnboardingState,
   OnboardingStep,
@@ -8,9 +9,10 @@ describe("@hw/extractOnboardingState", () => {
     describe("When the flag bytes are incorrect", () => {
       it("should throw an error", () => {
         const incompleteFlagsBytes = Buffer.from([0, 0]);
-        // DeviceExtractOnboardingStateError is not of type Error,
-        // so cannot check in toThrow(DeviceExtractOnboardingStateError)
-        expect(() => extractOnboardingState(incompleteFlagsBytes)).toThrow();
+
+        expect(() => extractOnboardingState(incompleteFlagsBytes)).toThrow(
+          DeviceExtractOnboardingStateError
+        );
       });
     });
 
@@ -75,17 +77,17 @@ describe("@hw/extractOnboardingState", () => {
         });
       });
 
-      describe("and the user is choosing what kind of setup they want", () => {
+      describe("and the user is on 'choose name' step", () => {
         beforeEach(() => {
-          flagsBytes[3] = 5;
+          flagsBytes[3] = 12;
         });
 
-        it("should return an onboarding step that is set at the setup choice", () => {
+        it("should return an onboarding step that is set at ready", () => {
           const onboardingState = extractOnboardingState(flagsBytes);
 
           expect(onboardingState).not.toBeNull();
           expect(onboardingState?.currentOnboardingStep).toBe(
-            OnboardingStep.SetupChoice
+            OnboardingStep.ChooseName
           );
         });
       });
@@ -105,6 +107,21 @@ describe("@hw/extractOnboardingState", () => {
         });
       });
 
+      describe("and the user is choosing what kind of setup they want", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 5;
+        });
+
+        it("should return an onboarding step that is set at the setup choice", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.SetupChoice
+          );
+        });
+      });
+
       describe("and the user is generating a new seed", () => {
         describe("and the seed phrase type is set to 24 words", () => {
           beforeEach(() => {
@@ -175,7 +192,22 @@ describe("@hw/extractOnboardingState", () => {
         });
       });
 
-      describe("and the user is recovering a seed", () => {
+      describe("and the user wants to restore a seed, choosing between restoring their own seed or Recover", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 14;
+        });
+
+        it("should return an onboarding step that is set at the setup restore choice", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.SetupChoiceRestore
+          );
+        });
+      });
+
+      describe("and the user is restoring a seed directly (without Recover)", () => {
         describe("and the seed phrase type is set to X words", () => {
           it("should return a device state with the correct seed phrase type", () => {
             const byte3 = flagsBytes[2];
@@ -234,32 +266,32 @@ describe("@hw/extractOnboardingState", () => {
         });
       });
 
-      describe("and the user is on the safety warning screen", () => {
+      describe("and the user wants to restore with Recover", () => {
         beforeEach(() => {
-          flagsBytes[3] = 10;
+          flagsBytes[3] = 13;
         });
 
-        it("should return an onboarding step that is set at the safety warning screen", () => {
+        it("should return an onboarding step that is set at the restore with Recover", () => {
           const onboardingState = extractOnboardingState(flagsBytes);
 
           expect(onboardingState).not.toBeNull();
           expect(onboardingState?.currentOnboardingStep).toBe(
-            OnboardingStep.SafetyWarning
+            OnboardingStep.RecoverRestore
           );
         });
       });
 
-      describe("and the user is on 'choose name' step", () => {
+      describe("and the user is on the safety warning screen", () => {
         beforeEach(() => {
-          flagsBytes[3] = 12;
+          flagsBytes[3] = 10;
         });
 
-        it("should return an onboarding step that is set at ready", () => {
+        it("should return an onboarding step that is set at the safety warning screen", () => {
           const onboardingState = extractOnboardingState(flagsBytes);
 
           expect(onboardingState).not.toBeNull();
           expect(onboardingState?.currentOnboardingStep).toBe(
-            OnboardingStep.ChooseName
+            OnboardingStep.SafetyWarning
           );
         });
       });
@@ -278,6 +310,21 @@ describe("@hw/extractOnboardingState", () => {
           );
         });
       });
+
+      describe("and the device is set to an onboarding step/flag that is not handled yet", () => {
+        beforeEach(() => {
+          // To update so it's never handled
+          flagsBytes[3] = 20;
+        });
+
+        it("should thrown an error", () => {
+          // DeviceExtractOnboardingStateError is not of type Error,
+          // so cannot check in toThrow(DeviceExtractOnboardingStateError)
+          expect(() => extractOnboardingState(flagsBytes)).toThrow(
+            DeviceExtractOnboardingStateError
+          );
+        });
+      });
     });
   });
 });

package/src/hw/extractOnboardingState.ts

@@ -30,14 +30,16 @@ export enum OnboardingStep {
   WelcomeScreen3 = "WELCOME_SCREEN_3",
   WelcomeScreen4 = "WELCOME_SCREEN_4",
   WelcomeScreenReminder = "WELCOME_SCREEN_REMINDER",
-  SetupChoice = "SETUP_CHOICE",
+  ChooseName = "CHOOSE_NAME",
   Pin = "PIN",
+  SetupChoice = "SETUP_CHOICE",
   NewDevice = "NEW_DEVICE", // path "new device" & currentSeedWordIndex available
   NewDeviceConfirming = "NEW_DEVICE_CONFIRMING", // path "new device" & currentSeedWordIndex available
+  SetupChoiceRestore = "SETUP_CHOICE_RESTORE", // choosing between restoring a see directly (RestoreSeed) or use Recover (RecoverRestore)
   RestoreSeed = "RESTORE_SEED", // path "restore seed" & currentSeedWordIndex available
+  RecoverRestore = "RECOVER_RESTORE", // path "restore with Recover"
   SafetyWarning = "SAFETY WARNING",
   Ready = "READY",
-  ChooseName = "CHOOSE_NAME",
 }
 
 const fromBitsToOnboardingStep = new Map<number, OnboardingStep>([
@@ -54,6 +56,8 @@ const fromBitsToOnboardingStep = new Map<number, OnboardingStep>([
   [10, OnboardingStep.SafetyWarning],
   [11, OnboardingStep.Ready],
   [12, OnboardingStep.ChooseName],
+  [13, OnboardingStep.RecoverRestore],
+  [14, OnboardingStep.SetupChoiceRestore],
 ]);
 
 export type OnboardingState = {