@ledgerhq/live-common 34.40.0 → 34.41.0-nightly.1

package/src/e2e/enum/Provider.ts

@@ -16,6 +16,9 @@ export class Provider {
   static readonly LIFI = new Provider("lifi", "LI.FI", false, true, false);
   static readonly CIC = new Provider("cic", "CIC", false, true, true);
   static readonly COINBASE = new Provider("coinbase", "Coinbase", false, true, true);
+  static readonly KILN = new Provider("kiln", "Kiln staking Pool", false, true, true);
+  static readonly STADER_LABS = new Provider("stader", "Stader Labs", false, true, true);
+  static readonly LIDO = new Provider("lido", "Lido", false, true, true);
 
   static getNameByUiName(uiName: string): string {
     const provider = Object.values(Provider).find(p => p.uiName === uiName);

package/src/e2e/speculos.ts

@@ -672,12 +672,14 @@ export async function signDelegationTransaction(delegatingAccount: Delegate) {
 }
 
 export async function verifyAmountsAndAcceptSwap(swap: Swap, amount: string) {
+  await waitFor(DeviceLabels.REVIEW_TRANSACTION);
   const events = await pressUntilTextFound(DeviceLabels.ACCEPT);
   await verifySwapData(swap, events, amount);
   await pressBoth();
 }
 
 export async function verifyAmountsAndRejectSwap(swap: Swap, amount: string) {
+  await waitFor(DeviceLabels.REVIEW_TRANSACTION);
   const events = await pressUntilTextFound(DeviceLabels.REJECT);
   await verifySwapData(swap, events, amount);
   await pressBoth();

package/src/exchange/error.ts

@@ -31,3 +31,13 @@ export function convertTransportError(
   }
   return err;
 }
+
+export function getSwapStepFromError(error: Error): string {
+  if ((error as CompleteExchangeError).step) {
+    return (error as CompleteExchangeError).step;
+  } else if (error.name === "DisabledTransactionBroadcastError") {
+    return "SIGN_COIN_TRANSACTION";
+  }
+
+  return "UNKNOWN_STEP";
+}

package/src/exchange/swap/api/v5/actions.ts

@@ -0,0 +1,36 @@
+import axios from "axios";
+import { getSwapAPIBaseURL } from "../..";
+import { SwapPayloadRequestData, SwapPayloadResponse } from "../../types";
+
+export async function retrieveSwapPayload(
+  data: SwapPayloadRequestData,
+): Promise<SwapPayloadResponse> {
+  const SWAP_API_BASE = getSwapAPIBaseURL();
+
+  const swapAxiosClient = axios.create({
+    baseURL: SWAP_API_BASE,
+  });
+
+  const request = {
+    provider: data.provider,
+    deviceTransactionId: data.deviceTransactionId,
+    from: data.fromAccountCurrency,
+    to: data.toNewTokenId || data.toAccountCurrency,
+    address: data.toAccountAddress,
+    refundAddress: data.fromAccountAddress,
+    amountFrom: data.amount,
+    amountFromInSmallestDenomination: Number(data.amountInAtomicUnit),
+    rateId: data.quoteId,
+  };
+
+  const res = await swapAxiosClient.post(`${SWAP_API_BASE}/swap`, request);
+
+  return {
+    binaryPayload: res.data?.binaryPayload,
+    signature: res.data?.signature,
+    payinAddress: res.data?.payinAddress,
+    swapId: res.data?.swapId,
+    payinExtraId: res.data?.payinExtraId,
+    extraTransactionParameters: res.data?.extraTransactionParameters,
+  };
+}

package/src/exchange/swap/completeExchange.ts

@@ -25,6 +25,8 @@ import { CompleteExchangeStep, convertTransportError } from "../error";
 import type { CompleteExchangeInputSwap, CompleteExchangeRequestEvent } from "../platform/types";
 import { convertToAppExchangePartnerKey, getSwapProvider } from "../providers";
 import { CEXProviderConfig } from "../providers/swap";
+import { isAddressSanctioned } from "@ledgerhq/coin-framework/sanction/index";
+import { AddressesSanctionedError } from "@ledgerhq/coin-framework/sanction/errors";
 
 const COMPLETE_EXCHANGE_LOG = "SWAP-CompleteExchange";
 
@@ -64,6 +66,18 @@ const completeExchange = (
         const payoutCurrency = getAccountCurrency(toAccount);
         const refundCurrency = getAccountCurrency(fromAccount);
         const mainRefundCurrency = getAccountCurrency(refundAccount);
+
+        const sanctionedAddresses: string[] = [];
+        for (const acc of [refundAccount, payoutAccount]) {
+          const isSanctioned = await isAddressSanctioned(acc.currency, acc.freshAddress);
+          if (isSanctioned) sanctionedAddresses.push(acc.freshAddress);
+        }
+
+        if (sanctionedAddresses.length > 0) {
+          throw new AddressesSanctionedError("AddressesSanctionedError", {
+            addresses: sanctionedAddresses,
+          });
+        }
         if (mainPayoutCurrency.type !== "CryptoCurrency")
           throw new Error("This should be a cryptocurrency");
         if (mainRefundCurrency.type !== "CryptoCurrency")

package/src/exchange/swap/getCompleteSwapHistory.ts

@@ -49,7 +49,7 @@ const getSwapOperationMap =
       if (account && toAccount && status) {
         let fromParentAccount;
 
-        if (account.type !== "Account") {
+        if (account.type === "TokenAccount") {
           fromParentAccount = accounts.find(a => a.id === account.parentId);
         }
 

package/src/exchange/swap/postSwapState.ts

@@ -1,4 +1,4 @@
-import network from "@ledgerhq/live-network/network";
+import network from "@ledgerhq/live-network";
 import { mockPostSwapAccepted, mockPostSwapCancelled } from "./mock";
 import type { PostSwapAccepted, PostSwapCancelled } from "./types";
 import { isIntegrationTestEnv } from "./utils/isIntegrationTestEnv";
@@ -8,25 +8,31 @@ export const postSwapAccepted: PostSwapAccepted = async ({
   provider,
   swapId = "",
   transactionId,
+  swapAppVersion,
   ...rest
 }) => {
   if (isIntegrationTestEnv())
     return mockPostSwapAccepted({ provider, swapId, transactionId, ...rest });
 
   /**
-   * Since swapId is requiered by the endpoit, don't call it if we don't have
+   * Since swapId is required by the endpoint, don't call it if we don't have
    * this info
    */
   if (!swapId) {
     return null;
   }
   try {
-    const headers = getSwapUserIP();
+    const ipHeader = getSwapUserIP();
+    const headers = {
+      ...(ipHeader || {}),
+      ...(swapAppVersion ? { "x-swap-app-version": swapAppVersion } : {}),
+    };
+
     await network({
       method: "POST",
       url: `${getSwapAPIBaseURL()}/swap/accepted`,
       data: { provider, swapId, transactionId, ...rest },
-      ...(headers !== undefined ? { headers } : {}),
+      ...(Object.keys(headers).length > 0 ? { headers } : {}),
     });
   } catch (error) {
     console.error(error);
@@ -35,11 +41,16 @@ export const postSwapAccepted: PostSwapAccepted = async ({
   return null;
 };
 
-export const postSwapCancelled: PostSwapCancelled = async ({ provider, swapId = "", ...rest }) => {
+export const postSwapCancelled: PostSwapCancelled = async ({
+  provider,
+  swapId = "",
+  swapAppVersion,
+  ...rest
+}) => {
   if (isIntegrationTestEnv()) return mockPostSwapCancelled({ provider, swapId, ...rest });
 
   /**
-   * Since swapId is requiered by the endpoit, don't call it if we don't have
+   * Since swapId is required by the endpoint, don't call it if we don't have
    * this info
    */
   if (!swapId) {
@@ -47,10 +58,17 @@ export const postSwapCancelled: PostSwapCancelled = async ({ provider, swapId =
   }
 
   try {
+    const ipHeader = getSwapUserIP();
+    const headers = {
+      ...(ipHeader || {}),
+      ...(swapAppVersion ? { "x-swap-app-version": swapAppVersion } : {}),
+    };
+
     await network({
       method: "POST",
       url: `${getSwapAPIBaseURL()}/swap/cancelled`,
       data: { provider, swapId, ...rest },
+      ...(Object.keys(headers).length > 0 ? { headers } : {}),
     });
   } catch (error) {
     console.error(error);

package/src/exchange/swap/setBroadcastTransaction.ts

@@ -11,13 +11,15 @@ export const setBroadcastTransaction = ({
   targetCurrencyId,
   hardwareWalletType,
   swapType,
+  swapAppVersion,
 }: {
-  result: { operation: Operation; swapId: string };
+  result: { operation: Operation | string; swapId: string };
   provider: string;
   sourceCurrencyId?: string;
   targetCurrencyId?: string;
   hardwareWalletType?: DeviceModelId;
   swapType?: TradeMethod;
+  swapAppVersion?: string;
 }) => {
   const { operation, swapId } = result;
 
@@ -36,16 +38,18 @@ export const setBroadcastTransaction = ({
       targetCurrencyId,
       hardwareWalletType,
       swapType: swapType,
+      swapAppVersion,
     });
   } else {
     postSwapAccepted({
       provider,
       swapId,
-      transactionId: operation.hash,
+      transactionId: typeof operation === "string" ? operation : operation.hash,
       sourceCurrencyId,
       targetCurrencyId,
       hardwareWalletType,
       swapType,
+      swapAppVersion,
     });
   }
 };

package/src/exchange/swap/transactionStrategies.ts

@@ -0,0 +1,234 @@
+import { BigNumber } from "bignumber.js";
+
+import {
+  CosmosTransaction,
+  ElrondTransaction,
+  RippleTransaction,
+  SolanaTransaction,
+  StellarTransaction,
+  TonTransaction,
+  Transaction,
+  TransactionCommon,
+} from "@ledgerhq/wallet-api-client";
+
+export type { SwapLiveError } from "@ledgerhq/wallet-api-exchange-module";
+
+export function defaultTransaction({
+  family,
+  amount,
+  recipient,
+  customFeeConfig,
+}: TransactionWithCustomFee): Transaction {
+  return <Transaction>{
+    family,
+    amount,
+    recipient,
+    ...customFeeConfig,
+  };
+}
+
+export function modeSendTransaction({
+  family,
+  amount,
+  recipient,
+  customFeeConfig,
+}: TransactionWithCustomFee): Transaction {
+  return {
+    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
+    mode: "send",
+  };
+}
+
+export function stellarTransaction({
+  family,
+  amount,
+  recipient,
+  customFeeConfig,
+  payinExtraId,
+  customErrorType,
+}: TransactionWithCustomFee): StellarTransaction {
+  if (!payinExtraId)
+    throw {
+      error: new Error("Missing payinExtraId"),
+      step: "PayinExtraIdStepError",
+      customErrorType,
+    };
+
+  return {
+    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
+    family: "stellar",
+    memoValue: payinExtraId,
+    memoType: "MEMO_TEXT",
+  };
+}
+
+export function rippleTransaction({
+  amount,
+  recipient,
+  customFeeConfig,
+  payinExtraId,
+  customErrorType,
+}: TransactionWithCustomFee): RippleTransaction {
+  if (!payinExtraId)
+    throw {
+      error: new Error("Missing payinExtraId"),
+      step: "PayinExtraIdStepError",
+      customErrorType,
+    };
+
+  const transaction: RippleTransaction = {
+    family: "ripple",
+    amount,
+    recipient,
+    ...customFeeConfig,
+    tag: new BigNumber(payinExtraId).toNumber(),
+  };
+  return transaction;
+}
+
+// Function to remove gasLimit from customFeeConfig for Ethereum or Bitcoin
+export function withoutGasLimitTransaction({
+  family,
+  amount,
+  recipient,
+  customFeeConfig,
+  extraTransactionParameters,
+}: TransactionWithCustomFee): Transaction {
+  if (customFeeConfig?.gasLimit) {
+    delete customFeeConfig.gasLimit;
+  }
+
+  if (extraTransactionParameters) {
+    return <Transaction>{
+      family,
+      amount,
+      recipient,
+      ...customFeeConfig,
+      data: Buffer.from(extraTransactionParameters, "hex"),
+    };
+  }
+  return defaultTransaction({ family, amount, recipient, customFeeConfig });
+}
+
+export function bitcoinTransaction({
+  amount,
+  recipient,
+  customFeeConfig,
+  extraTransactionParameters,
+}: TransactionWithCustomFee): Transaction {
+  if (extraTransactionParameters) {
+    return {
+      family: "bitcoin",
+      amount,
+      recipient,
+      ...customFeeConfig,
+      opReturnData: Buffer.from(extraTransactionParameters, "utf-8"),
+    };
+  }
+  return {
+    family: "bitcoin",
+    amount,
+    recipient,
+    ...customFeeConfig,
+  };
+}
+
+export function solanaTransaction({
+  family,
+  amount,
+  recipient,
+  customFeeConfig,
+}: TransactionWithCustomFee): SolanaTransaction {
+  return {
+    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
+    family: "solana",
+    model: { kind: "transfer", uiState: {} },
+  };
+}
+
+export function elrondTransaction({
+  amount,
+  recipient,
+  customFeeConfig,
+}: TransactionWithCustomFee): ElrondTransaction {
+  const transaction: ElrondTransaction = {
+    family: "elrond",
+    amount,
+    recipient,
+    mode: "send",
+    ...customFeeConfig,
+    gasLimit: 0, // FIXME: Placeholder, adjust as needed
+  };
+  return transaction;
+}
+
+function tonTransaction({
+  family,
+  amount,
+  recipient,
+  customFeeConfig,
+}: TransactionWithCustomFee): TonTransaction {
+  return {
+    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
+    family: "ton",
+    comment: { isEncrypted: false, text: "" },
+    fees: new BigNumber(0), // Set default value as completeExchange call prepareTransaction, which set again fees.
+  };
+}
+
+export function cosmosTransaction({
+  family,
+  amount,
+  recipient,
+  customFeeConfig,
+  payinExtraId,
+}: TransactionWithCustomFee): CosmosTransaction {
+  return <CosmosTransaction>{
+    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
+    family: "cosmos",
+    mode: "send",
+    memo: payinExtraId ?? undefined,
+  };
+}
+
+export type TransactionWithCustomFee = TransactionCommon & {
+  customFeeConfig: {
+    [key: string]: BigNumber;
+  };
+  payinExtraId?: string;
+  customErrorType?: "swap";
+  extraTransactionParameters?: string;
+};
+
+// Define a specific type for the strategy functions, assuming they might need parameters
+export type TransactionStrategyFunction = (params: TransactionWithCustomFee) => Transaction;
+
+export const transactionStrategy: {
+  [K in Transaction["family"]]: TransactionStrategyFunction;
+} = {
+  algorand: defaultTransaction,
+  aptos: defaultTransaction,
+  bitcoin: bitcoinTransaction,
+  cardano: modeSendTransaction,
+  celo: defaultTransaction,
+  cosmos: cosmosTransaction,
+  crypto_org: defaultTransaction,
+  elrond: elrondTransaction,
+  ethereum: withoutGasLimitTransaction,
+  filecoin: defaultTransaction,
+  hedera: defaultTransaction,
+  near: modeSendTransaction,
+  neo: defaultTransaction,
+  polkadot: defaultTransaction,
+  ripple: rippleTransaction,
+  solana: solanaTransaction,
+  stacks: defaultTransaction,
+  stellar: stellarTransaction,
+  tezos: modeSendTransaction,
+  ton: tonTransaction,
+  tron: modeSendTransaction,
+  vechain: defaultTransaction,
+  casper: defaultTransaction,
+  sui: defaultTransaction,
+  internet_computer: defaultTransaction,
+};

package/src/exchange/swap/types.ts

@@ -4,6 +4,7 @@ import { Account, AccountLike, AccountRaw, AccountRawLike, Operation } from "@le
 import { BigNumber } from "bignumber.js";
 import { Result as UseBridgeTransactionResult } from "../../bridge/useBridgeTransaction";
 import { Transaction, TransactionRaw } from "../../generated/types";
+
 export type { SwapLiveError } from "@ledgerhq/wallet-api-exchange-module";
 
 export type ExchangeSwap = {
@@ -198,6 +199,7 @@ type SwapStateRequest = {
   targetCurrencyId: string;
   hardwareWalletType: DeviceModelId;
   swapType: TradeMethod;
+  swapAppVersion?: string;
 }>;
 
 export type SwapStateAcceptedRequest = SwapStateRequest & {
@@ -336,3 +338,65 @@ export type SwapTransactionType = UseBridgeTransactionResult & {
   fromAmountError?: Error;
   fromAmountWarning?: Error;
 };
+
+export type SwapPayloadRequestData = {
+  provider: string;
+  deviceTransactionId: string;
+  fromAccountAddress: string;
+  toAccountAddress: string;
+  fromAccountCurrency: string;
+  toAccountCurrency: string;
+  amount: string;
+  amountInAtomicUnit: number;
+  quoteId?: string;
+  toNewTokenId?: string;
+};
+export type SwapPayloadResponse = {
+  binaryPayload: string;
+  signature: string;
+  payinAddress: string;
+  swapId: string;
+  payinExtraId?: string;
+  extraTransactionParameters?: string;
+};
+
+export type ConfirmSwapRequest = {
+  provider: string;
+  swapId: string;
+  transactionId: string;
+  sourceCurrencyId?: string;
+  targetCurrencyId?: string;
+  hardwareWalletType?: string;
+};
+
+export type CancelSwapRequest = {
+  provider: string;
+  swapId: string;
+  statusCode?: string;
+  errorMessage?: string;
+  sourceCurrencyId?: string;
+  targetCurrencyId?: string;
+  hardwareWalletType?: string;
+  swapType?: string;
+  swapStep?: string;
+};
+
+export type SwapBackendResponse = {
+  provider: string;
+  swapId: string;
+  apiExtraFee: number;
+  apiFee: number;
+  refundAddress: string;
+  amountExpectedFrom: number;
+  amountExpectedTo: number;
+  status: string;
+  from: string;
+  to: string;
+  payinAddress: string;
+  payoutAddress: string;
+  createdAt: string; // ISO-8601
+  binaryPayload: string;
+  signature: string;
+  payinExtraId?: string;
+  extraTransactionParameters?: string;
+};

package/src/families/cardano/__snapshots__/bridge.integration.test.ts.snap

@@ -7,6 +7,7 @@ exports[`cardano_testnet currency bridge scanAccounts cardano_testnet seed 1 1`]
     "cardanoResources": {
       "delegation": {
         "dRepHex": undefined,
+        "deposit": "2000000",
         "name": "Apex Cardano Pool",
         "poolId": "7facad662e180ce45e5c504957cd1341940c72a708728f7ecfc6e349",
         "rewards": "0",

package/src/families/cardano/signerSerializer.ts

@@ -121,9 +121,10 @@ function prepareCertificate(cert: SignerTxCertificate): Certificate {
   switch (cert.type) {
     case "REGISTRATION":
       return {
-        type: CertificateType.STAKE_REGISTRATION,
+        type: CertificateType.STAKE_REGISTRATION_CONWAY,
         params: {
           stakeCredential,
+          deposit: cert.params.deposit,
         },
       };
     case "DELEGATION":
@@ -136,9 +137,10 @@ function prepareCertificate(cert: SignerTxCertificate): Certificate {
       };
     case "DEREGISTRATION":
       return {
-        type: CertificateType.STAKE_DEREGISTRATION,
+        type: CertificateType.STAKE_DEREGISTRATION_CONWAY,
         params: {
           stakeCredential,
+          deposit: cert.params.deposit,
         },
       };
     case "VOTE_DELEGATION_ABSTAIN":

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

@@ -14,7 +14,7 @@ import {
   getSerializedAddressParameters,
   updateTransaction,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { getGasLimit } from "@ledgerhq/coin-evm/logic";
+import { getGasLimit } from "@ledgerhq/coin-evm/utils";
 import { getTypedTransaction } from "@ledgerhq/coin-evm/transaction";
 const receive = makeAccountBridgeReceive();
 const defaultGetFees = (_a, t: any) => (t.gasPrice || new BigNumber(0)).times(getGasLimit(t));

package/src/families/evm/platformAdapter.test.ts

@@ -1,8 +1,8 @@
-import { DEFAULT_NONCE } from "@ledgerhq/coin-evm/createTransaction";
 import { Transaction } from "@ledgerhq/coin-evm/types/index";
 import { FAMILIES, EthereumTransaction as PlatformTransaction } from "@ledgerhq/live-app-sdk";
 import BigNumber from "bignumber.js";
 import evm from "./platformAdapter";
+import { DEFAULT_NONCE } from "@ledgerhq/coin-evm/utils";
 
 describe("getPlatformTransactionSignFlowInfos", () => {
   describe("should properly get infos for ETH platform tx", () => {

package/src/families/evm/platformAdapter.ts

@@ -1,6 +1,6 @@
 // TODO: to remove once live-app-sdk is depreciated and removed from LL
 
-import { DEFAULT_NONCE } from "@ledgerhq/coin-evm/createTransaction";
+import { DEFAULT_NONCE } from "@ledgerhq/coin-evm/utils";
 import { Transaction } from "@ledgerhq/coin-evm/types/index";
 import { EthereumTransaction as PlatformTransaction } from "@ledgerhq/live-app-sdk";
 

package/src/families/evm/react.test.ts

@@ -4,15 +4,15 @@
 import BigNumber from "bignumber.js";
 import { renderHook, waitFor } from "@testing-library/react";
 import { Transaction } from "@ledgerhq/coin-evm/types/index";
-import { getGasTracker } from "@ledgerhq/coin-evm/api/gasTracker/index";
-import type { GasTrackerApi } from "@ledgerhq/coin-evm/api/gasTracker/types";
+import { getGasTracker } from "@ledgerhq/coin-evm/network/gasTracker/index";
+import type { GasTrackerApi } from "@ledgerhq/coin-evm/network/gasTracker/types";
 import { CryptoCurrency, CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
 import { useGasOptions } from "./react";
 
 jest.useFakeTimers();
 jest.spyOn(global, "setInterval");
 
-jest.mock("@ledgerhq/coin-evm/api/gasTracker/index");
+jest.mock("@ledgerhq/coin-evm/network/gasTracker/index");
 const mockedGetGasTracker = jest.mocked(getGasTracker);
 
 const mockedGetGasOptions = jest.fn();

package/src/families/evm/react.ts

@@ -1,4 +1,4 @@
-import { getGasTracker } from "@ledgerhq/coin-evm/api/gasTracker/index";
+import { getGasTracker } from "@ledgerhq/coin-evm/network/gasTracker/index";
 import type { GasOptions, Transaction } from "@ledgerhq/coin-evm/types/index";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { useEffect, useMemo, useState } from "react";

package/src/families/evm/walletApiAdapter.ts

@@ -1,4 +1,4 @@
-import { createTransaction } from "@ledgerhq/coin-evm/createTransaction";
+import { createTransaction } from "@ledgerhq/coin-evm/bridge/createTransaction";
 import { Transaction } from "@ledgerhq/coin-evm/types/index";
 import { EthereumTransaction as WalletAPIEthereumTransaction } from "@ledgerhq/wallet-api-core";
 import {

package/src/featureFlags/defaultFeatures.ts

@@ -153,6 +153,7 @@ export const DEFAULT_FEATURES: Features = {
   protectServicesDesktop: {
     enabled: false,
     params: {
+      openWithDevTools: false,
       availableOnDesktop: false,
       isNew: false,
       ledgerliveStorageState: false,
@@ -530,7 +531,6 @@ export const DEFAULT_FEATURES: Features = {
     ...DEFAULT_FEATURE,
     params: { link: null },
   },
-  llmNetworkBasedAddAccountFlow: DEFAULT_FEATURE,
   llCounterValueGranularitiesRates: {
     ...DEFAULT_FEATURE,
     params: {

package/src/hw/extractOnboardingState.test.ts

@@ -35,6 +35,15 @@ describe("@hw/extractOnboardingState", () => {
             expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
             expect(onboardingState?.charonStatus).toBeNull();
           });
+
+          it("should ignore charon update status", () => {
+            const charonState = Buffer.from([0x20]);
+            const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
+            expect(onboardingState?.charonStatus).toBeNull();
+          });
         });
 
         describe("and the user refuse to backup the charon", () => {