@ledgerhq/live-config 1.0.0-next.0

package/src/featureFlags/defaultFeatures.ts

@@ -0,0 +1,428 @@
+import { DefaultFeature, Feature, Features, FeatureMap } from "@ledgerhq/types-live";
+import { reduce } from "lodash";
+import { formatToFirebaseFeatureId } from "./firebaseFeatureFlags";
+
+/**
+ * Default disabled feature.
+ */
+const DEFAULT_FEATURE: DefaultFeature = {
+  enabled: false,
+};
+
+/**
+ * Util function that create a default feature and type its return.
+ *
+ * @dev needed for proper type infering.
+ *
+ * @param opts
+ * @returns typed `opts` parameter or the default feature.
+ */
+export const initFeature = <T>(opts?: Feature<T>) => {
+  const feature = opts ?? DEFAULT_FEATURE;
+  return feature as Feature<T>;
+};
+
+/**
+ * Currency Features.
+ */
+export const CURRENCY_DEFAULT_FEATURES = {
+  currencyArbitrum: DEFAULT_FEATURE,
+  currencyArbitrumGoerli: DEFAULT_FEATURE,
+  currencyAstar: DEFAULT_FEATURE,
+  currencyAvalancheCChain: DEFAULT_FEATURE,
+  currencyAxelar: DEFAULT_FEATURE,
+  currencyBase: DEFAULT_FEATURE,
+  currencyBaseGoerli: DEFAULT_FEATURE,
+  currencyBittorrent: DEFAULT_FEATURE,
+  currencyBoba: DEFAULT_FEATURE,
+  currencyCoreum: DEFAULT_FEATURE,
+  currencyDesmos: DEFAULT_FEATURE,
+  currencyDydx: DEFAULT_FEATURE,
+  currencyEnergyWeb: DEFAULT_FEATURE,
+  currencyEvmosEvm: DEFAULT_FEATURE,
+  currencyInjective: DEFAULT_FEATURE,
+  currencyInternetComputer: DEFAULT_FEATURE,
+  currencyKavaEvm: DEFAULT_FEATURE,
+  currencyKlaytn: DEFAULT_FEATURE,
+  currencyLukso: DEFAULT_FEATURE,
+  currencyMetis: DEFAULT_FEATURE,
+  currencyMoonriver: DEFAULT_FEATURE,
+  currencyOnomy: DEFAULT_FEATURE,
+  currencyOptimism: DEFAULT_FEATURE,
+  currencyOptimismGoerli: DEFAULT_FEATURE,
+  currencyPersistence: DEFAULT_FEATURE,
+  currencyPolygonZkEvm: DEFAULT_FEATURE,
+  currencyPolygonZkEvmTestnet: DEFAULT_FEATURE,
+  currencyQuicksilver: DEFAULT_FEATURE,
+  currencyRsk: DEFAULT_FEATURE,
+  currencySecretNetwork: DEFAULT_FEATURE,
+  currencySeiNetwork: DEFAULT_FEATURE,
+  currencyStacks: DEFAULT_FEATURE,
+  currencyStargaze: DEFAULT_FEATURE,
+  currencySyscoin: DEFAULT_FEATURE,
+  currencyTelosEvm: DEFAULT_FEATURE,
+  currencyUmee: DEFAULT_FEATURE,
+  currencyVechain: DEFAULT_FEATURE,
+  currencyVelasEvm: DEFAULT_FEATURE,
+  currencyCasper: DEFAULT_FEATURE,
+  currencyNeonEvm: DEFAULT_FEATURE,
+};
+
+/**
+ * Default Features.
+ */
+export const DEFAULT_FEATURES: Features = {
+  ...CURRENCY_DEFAULT_FEATURES,
+
+  brazeLearn: DEFAULT_FEATURE,
+  objkt: DEFAULT_FEATURE,
+  portfolioExchangeBanner: DEFAULT_FEATURE,
+  postOnboardingAssetsTransfer: DEFAULT_FEATURE,
+  postOnboardingClaimNft: DEFAULT_FEATURE,
+  syncOnboarding: DEFAULT_FEATURE,
+  walletConnectEntryPoint: DEFAULT_FEATURE,
+  counterValue: DEFAULT_FEATURE,
+  llmNewDeviceSelection: DEFAULT_FEATURE,
+  llmNewFirmwareUpdateUx: DEFAULT_FEATURE,
+  mockFeature: DEFAULT_FEATURE,
+  multibuyNavigation: DEFAULT_FEATURE,
+  ptxServiceCtaExchangeDrawer: DEFAULT_FEATURE,
+  ptxServiceCtaScreens: DEFAULT_FEATURE,
+  customImage: DEFAULT_FEATURE,
+  referralProgramDesktopBanner: DEFAULT_FEATURE,
+  disableNftLedgerMarket: DEFAULT_FEATURE,
+  disableNftRaribleOpensea: DEFAULT_FEATURE,
+  disableNftSend: DEFAULT_FEATURE,
+  staxWelcomeScreen: DEFAULT_FEATURE,
+  protectServicesDiscoverDesktop: DEFAULT_FEATURE,
+  llmWalletQuickActions: DEFAULT_FEATURE,
+  listAppsV2minor1: DEFAULT_FEATURE,
+  ethStakingProviders: initFeature(),
+  referralProgramDiscoverCard: initFeature(),
+  newsfeedPage: initFeature(),
+  ptxEarn: initFeature(),
+  swapWalletApiPartnerList: initFeature(),
+  stakePrograms: initFeature(),
+  learn: initFeature(),
+  receiveStakingFlowConfigDesktop: initFeature(),
+  brazePushNotifications: initFeature(),
+  walletNftGallery: initFeature(),
+  stakeAccountBanner: initFeature(),
+
+  buyDeviceFromLive: {
+    enabled: false,
+    params: { debug: false, url: null },
+  },
+
+  depositNetworkBannerMobile: {
+    enabled: false,
+    params: { url: "https://www.ledger.com/ledger-live" },
+  },
+
+  depositWithdrawBannerMobile: {
+    enabled: false,
+    params: { url: "https://www.ledger.com/ledger-live" },
+  },
+
+  deviceInitialApps: {
+    enabled: false,
+    params: { apps: ["Bitcoin", "Ethereum"] },
+  },
+
+  discover: {
+    enabled: false,
+    params: { version: "1" },
+  },
+
+  domainInputResolution: {
+    enabled: false,
+    params: { supportedCurrencyIds: ["ethereum"] },
+  },
+
+  editEvmTx: {
+    enabled: false,
+    params: { supportedCurrencyIds: ["ethereum"] },
+  },
+
+  referralProgramDesktopSidebar: {
+    enabled: false,
+    params: { amount: "$20", isNew: true, path: "/discover/refer-a-friend" },
+  },
+
+  referralProgramMobile: {
+    enabled: false,
+    params: { path: "/discover/refer-a-friend" },
+  },
+
+  protectServicesDesktop: {
+    enabled: false,
+    params: {
+      availableOnDesktop: false,
+      isNew: false,
+      ledgerliveStorageState: false,
+      bannerSubscriptionNotification: false,
+      account: {
+        homeURI:
+          "ledgerlive://recover/protect-simu?redirectTo=account&source=lld-sidebar-navigation&ajs_recover_source=lld-sidebar-navigation&ajs_recover_campaign=recover-launch",
+        loginURI:
+          "ledgerlive://recover/protect-simu?redirectTo=login&source=lld-welcome-login&ajs_recover_source=lld-welcome-login&ajs_recover_campaign=recover-launch",
+      },
+      compatibleDevices: [],
+      discoverTheBenefitsLink: "https://www.ledger.com/recover",
+      onboardingCompleted: {
+        alreadySubscribedURI: "ledgerlive://recover/protect-simu?redirectTo=login",
+        alreadyDeviceSeededURI:
+          "ledgerlive://recover/protect-simu?redirectTo=upsell&source=lld-pairing&ajs_recover_source=lld-pairing&ajs_recover_campaign=recover-launch",
+        upsellURI:
+          "ledgerlive://recover/protect-simu?redirectTo=upsell&source=lld-onboarding-24&ajs_recover_source=lld-onboarding-24&ajs_recover_campaign=recover-launch",
+        restore24URI:
+          "ledgerlive://recover/protect-simu?redirectTo=upsell&source=lld-restore-24&ajs_recover_source=lld-restore-24&ajs_recover_campaign=recover-launch",
+      },
+      onboardingRestore: {
+        postOnboardingURI:
+          "ledgerlive://recover/protect-simu?redirectTo=restore&source=lld-restore",
+        restoreInfoDrawer: {
+          enabled: true,
+          manualStepsURI:
+            "https://support.ledger.com/hc/en-us/articles/360013349800-Update-Ledger-Nano-X-firmware?docs=true",
+          supportLinkURI: "https://support.ledger.com",
+        },
+      },
+      openRecoverFromSidebar: true,
+      protectId: "protect-simu",
+    },
+  },
+
+  storyly: {
+    enabled: true,
+    params: {
+      stories: {
+        recoverySeed: {
+          testingEnabled: false,
+          token:
+            "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2NfaWQiOjY5NDgsImFwcF9pZCI6MTE0MjIsImluc19pZCI6MTQ4Mjl9.iak4gUnizDdPrEXJEV3wszzJ2YkYX-RIWDXv31aJkiE",
+        },
+        storylyExample: {
+          testingEnabled: false,
+          token:
+            "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhY2NfaWQiOjc2MCwiYXBwX2lkIjo0MDUsImluc19pZCI6NDA0fQ.1AkqOy_lsiownTBNhVOUKc91uc9fDcAxfQZtpm3nj40",
+        },
+        testStory: {
+          testingEnabled: false,
+          token:
+            "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhY2NfaWQiOjY5NDgsImFwcF9pZCI6MTE0MjIsImluc19pZCI6MTIxOTh9.XqNitheri5VPDqebtA4JFu1VucVOHYlryki2TqCb1DQ",
+        },
+      },
+    },
+  },
+
+  transactionsAlerts: {
+    enabled: false,
+    params: {
+      chainwatchBaseUrl: "https://chainwatch.aws.stg.ldg-tech.com/v0",
+      networks: [
+        {
+          chainwatchId: "eth",
+          ledgerLiveId: "ethereum",
+          nbConfirmations: 1,
+        },
+      ],
+    },
+  },
+
+  firebaseEnvironmentReadOnly: {
+    enabled: false,
+    params: {
+      comment:
+        "Do not modify this configuration. This is just a read-only helper to display the targeted Firebase environment in Ledger Live. The value of this flag has NO functional impact.",
+      project: "n/a (Firebase project could not be reached)",
+    },
+  },
+
+  npsRatingsPrompt: {
+    enabled: false,
+    params: {
+      conditions: {
+        disappointed_delay: {
+          seconds: 60,
+        },
+        minimum_accounts_number: 1,
+        minimum_app_starts_number: 0,
+        minimum_duration_since_app_first_start: {
+          seconds: 0,
+        },
+        minimum_number_of_app_starts_since_last_crash: 0,
+        not_now_delay: {
+          seconds: 30,
+        },
+        satisfied_then_not_now_delay: {
+          seconds: 90,
+        },
+      },
+      happy_moments: [
+        {
+          route_name: "ReceiveVerificationConfirmation",
+          timer: 2000,
+          type: "on_leave",
+        },
+        {
+          route_name: "ClaimRewardsValidationSuccess",
+          timer: 2000,
+          type: "on_enter",
+        },
+        {
+          route_name: "CosmosClaimRewardsValidationSuccess",
+          timer: 2000,
+          type: "on_enter",
+        },
+        {
+          route_name: "AlgorandClaimRewardsValidationSuccess",
+          timer: 2000,
+          type: "on_enter",
+        },
+        {
+          route_name: "SendValidationSuccess",
+          timer: 2000,
+          type: "on_enter",
+        },
+        {
+          route_name: "MarketDetail",
+          timer: 3000,
+          type: "on_enter",
+        },
+      ],
+      support_email: "support@ledger.com",
+      typeform_url:
+        "https://ledger.typeform.com/to/UsbZ0RBk?typeform-medium=embed-sdk&typeform-medium-version=next&typeform-embed=popup-blank&dev=1",
+    },
+  },
+
+  protectServicesMobile: {
+    enabled: false,
+    params: {
+      ledgerliveStorageState: false,
+      bannerSubscriptionNotification: false,
+      deeplink: "",
+      compatibleDevices: [],
+      account: {
+        homeURI:
+          "ledgerlive://recover/protect-simu?redirectTo=account&source=llm-myledger-access-card&ajs_prop_source=llm-myledger-access-card&ajs_prop_campaign=recover-launch",
+        loginURI:
+          "ledgerlive://recover/protect-simu?redirectTo=login&source=llm-myledger-access-card&ajs_prop_source=llm-myledger-access-card&ajs_prop_campaign=recover-launch",
+      },
+      managerStatesData: {
+        NEW: {
+          learnMoreURI:
+            "ledgerlive://recover/protect-simu?redirectTo=upsell&source=llm-onboarding-24&ajs_prop_source=llm-onboarding-24&ajs_prop_campaign=recover-launch",
+          alreadySubscribedURI:
+            "ledgerlive://recover/protect-simu?redirectTo=login&source=llm-onboarding-24&ajs_prop_source=llm-onboarding-24&ajs_prop_campaign=recover-launch",
+          quickAccessURI:
+            "ledgerlive://recover/protect-simu?redirectTo=upsell&source=llm-navbar-quick-access&ajs_prop_source=llm-navbar-quick-access&ajs_prop_campaign=recover-launch",
+          alreadyOnboardedURI:
+            "ledgerlive://recover/protect-simu?redirectTo=upsell&source=llm-pairing&ajs_prop_source=llm-pairing&ajs_prop_campaign=recover-launch",
+        },
+      },
+      onboardingRestore: {
+        postOnboardingURI:
+          "ledgerlive://recover/protect-simu?redirectTo=restore&source=llm-restore-24&ajs_prop_source=llm-restore-24&ajs_prop_campaign=recover-launch",
+        restoreInfoDrawer: {
+          enabled: true,
+          manualStepsURI:
+            "https://support.ledger.com/hc/en-us/articles/360013349800-Update-Ledger-Nano-X-firmware?docs=true",
+          supportLinkURI:
+            "http://chat.abhishekpriyam.com/sprinklrlivechatv2.php?appId=63453067138a3f453db323b4_app_300078397&env=prod3",
+        },
+      },
+      protectId: "protect-simu",
+    },
+  },
+
+  ratingsPrompt: {
+    enabled: false,
+    params: {
+      conditions: {
+        disappointed_delay: {
+          days: 90,
+        },
+        minimum_accounts_number: 3,
+        minimum_app_starts_number: 3,
+        minimum_duration_since_app_first_start: {
+          days: 3,
+        },
+        minimum_number_of_app_starts_since_last_crash: 2,
+        not_now_delay: {
+          days: 15,
+        },
+        satisfied_then_not_now_delay: {
+          days: 3,
+        },
+      },
+      happy_moments: [
+        {
+          route_name: "ReceiveConfirmation",
+          timer: 2000,
+          type: "on_enter",
+        },
+        {
+          route_name: "ClaimRewardsValidationSuccess",
+          timer: 2000,
+          type: "on_enter",
+        },
+        {
+          route_name: "SendValidationSuccess",
+          timer: 2000,
+          type: "on_enter",
+        },
+        {
+          route_name: "MarketDetail",
+          timer: 3000,
+          type: "on_enter",
+        },
+      ],
+      support_email: "support@ledger.com",
+      typeform_url:
+        "https://form.typeform.com/to/Jo7gqcB4?typeform-medium=embed-sdk&typeform-medium-version=next&typeform-embed=popup-blank",
+    },
+  },
+
+  cexDepositEntryPointsDesktop: {
+    enabled: false,
+    params: {
+      path: "/platform/ledger-cex-deposit",
+      locations: {
+        selectCrypto: true,
+      },
+    },
+  },
+
+  cexDepositEntryPointsMobile: {
+    enabled: false,
+    params: {
+      path: "/discover/ledger-cex-deposit",
+      locations: {
+        selectCrypto: true,
+      },
+    },
+  },
+
+  fetchAdditionalCoins: {
+    enabled: false,
+  },
+
+  ptxSwapLiveApp: {
+    enabled: false,
+  },
+
+  ptxSwapMoonpayProvider: DEFAULT_FEATURE,
+};
+
+// Firebase SDK treat JSON values as strings
+export const formatDefaultFeatures = (config: FeatureMap) =>
+  reduce(
+    config,
+    (acc, feature, featureId) => ({
+      ...acc,
+      [formatToFirebaseFeatureId(featureId)]: JSON.stringify(feature),
+    }),
+    {},
+  );

package/src/featureFlags/firebaseFeatureFlags.ts

@@ -0,0 +1,115 @@
+import { PropsWithChildren } from "react";
+import { snakeCase } from "lodash";
+import semver from "semver";
+import { Feature, FeatureId } from "@ledgerhq/types-live";
+import { getEnv } from "@ledgerhq/live-env";
+import { LiveConfig } from "./LiveConfig";
+
+export type FirebaseFeatureFlagsProviderProps = PropsWithChildren<unknown>;
+export const formatToFirebaseFeatureId = (id: string) => `feature_${snakeCase(id)}`;
+
+export const checkFeatureFlagVersion = (feature: Feature) => {
+  const platform = LiveConfig.getInstance().platform;
+  if (!feature?.enabled || !platform) {
+    return feature;
+  }
+  const featureSpecificVersion: string | undefined = (() => {
+    switch (platform) {
+      case "desktop":
+        return feature.desktop_version;
+      case "ios":
+      case "android":
+        return feature.mobile_version;
+      default:
+        return undefined;
+    }
+  })();
+  if (
+    featureSpecificVersion &&
+    !semver.satisfies(LiveConfig.getInstance().appVersion, featureSpecificVersion, {
+      includePrerelease: true,
+    })
+  ) {
+    return {
+      enabledOverriddenForCurrentVersion: true,
+      ...feature,
+      enabled: false,
+    };
+  }
+  return feature;
+};
+
+export const isFeature = (key: string): boolean => {
+  if (!LiveConfig.getInstance().providerGetvalueMethod) {
+    return false;
+  }
+  try {
+    const value = LiveConfig.getInstance().providerGetvalueMethod!["firebaseRemoteConfig"](
+      formatToFirebaseFeatureId(key),
+    );
+    if (!value || !value.asString()) {
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error(`Failed to check if feature "${key}" exists`);
+    return false;
+  }
+};
+
+export const getFeature = (args: {
+  key: FeatureId;
+  appLanguage?: string;
+  localOverrides?: { [key in FeatureId]?: Feature };
+  allowOverride?: boolean;
+}) => {
+  if (!LiveConfig.getInstance().providerGetvalueMethod) {
+    return null;
+  }
+  const { key, appLanguage, localOverrides, allowOverride = true } = args;
+  try {
+    // Nb prioritize local overrides
+    if (allowOverride && localOverrides && localOverrides[key]) {
+      const feature = localOverrides[key];
+      if (feature) {
+        return checkFeatureFlagVersion(feature);
+      }
+    }
+
+    const envFlags = getEnv("FEATURE_FLAGS") as { [key in FeatureId]?: Feature } | undefined;
+
+    if (allowOverride && envFlags) {
+      const feature = envFlags[key];
+      if (feature)
+        return {
+          ...feature,
+          overridesRemote: true,
+          overriddenByEnv: true,
+        };
+    }
+
+    const value = LiveConfig.getInstance().providerGetvalueMethod!["firebaseRemoteConfig"](
+      formatToFirebaseFeatureId(key),
+    );
+
+    const feature = JSON.parse(value.asString());
+
+    if (
+      feature.enabled &&
+      appLanguage &&
+      ((feature.languages_whitelisted && !feature.languages_whitelisted.includes(appLanguage)) ||
+        (feature.languages_blacklisted && feature.languages_blacklisted.includes(appLanguage)))
+    ) {
+      return {
+        enabledOverriddenForCurrentLanguage: true,
+        ...feature,
+        enabled: false,
+      };
+    }
+
+    return checkFeatureFlagVersion(feature);
+  } catch (error) {
+    console.error(`Failed to retrieve feature "${key}"`);
+    return null;
+  }
+};

package/src/featureFlags/groupedFeatures.ts

@@ -0,0 +1,25 @@
+import { FeatureId } from "@ledgerhq/types-live";
+
+/** Helper to group several feature flag ids under a common feature flag */
+export const groupedFeatures: Record<
+  string,
+  {
+    featureIds: FeatureId[];
+  }
+> = {
+  stax: {
+    featureIds: [
+      "customImage",
+      "deviceInitialApps",
+      "llmNewDeviceSelection",
+      "postOnboardingAssetsTransfer",
+      "postOnboardingClaimNft",
+      "staxWelcomeScreen",
+      "syncOnboarding",
+      "llmNewFirmwareUpdateUx",
+    ],
+  },
+  disableNft: {
+    featureIds: ["disableNftLedgerMarket", "disableNftRaribleOpensea", "disableNftSend"],
+  },
+};

package/src/featureFlags/helper.tsx

@@ -0,0 +1,9 @@
+export function isRecoverDisplayed(feature, deviceModelId) {
+  return (
+    feature?.enabled &&
+    feature?.params?.compatibleDevices?.find(
+      (device: { name: string; available: boolean }) =>
+        device.name === deviceModelId && device.available,
+    )
+  );
+}

package/src/featureFlags/index.ts

@@ -0,0 +1,12 @@
+import useFeature from "./useFeature";
+import FeatureToggle from "./FeatureToggle";
+
+export { useFeature, FeatureToggle };
+
+export * from "./defaultFeatures";
+export * from "./groupedFeatures";
+export * from "./FeatureFlagsContext";
+export * from "./useHasOverriddenFeatureFlags";
+export * from "./firebaseFeatureFlags";
+export * from "./LiveConfig";
+export * from "./helper";

package/src/featureFlags/mock.tsx

@@ -0,0 +1,28 @@
+import React from "react";
+import { Feature, FeatureId } from "@ledgerhq/types-live";
+import { FeatureFlagsContextValue, FeatureFlagsProvider } from "./FeatureFlagsContext";
+
+export function makeMockedContextValue(
+  mockedFeatures: Partial<Record<FeatureId, Feature>>,
+): FeatureFlagsContextValue {
+  return {
+    isFeature: () => true,
+    getFeature: (featureId: FeatureId) => mockedFeatures[featureId] || null,
+    overrideFeature: () => {},
+    resetFeature: () => {},
+    resetFeatures: () => {},
+  };
+}
+
+export function makeMockedFeatureFlagsProviderWrapper(
+  mockedContextValue: FeatureFlagsContextValue,
+) {
+  const MockedFeatureProviderWrapper: React.FC<{ children: React.ReactNode | null }> = ({
+    children,
+  }) => <FeatureFlagsProvider value={mockedContextValue}>{children}</FeatureFlagsProvider>;
+  return MockedFeatureProviderWrapper;
+}
+
+export const basicMockedFeatureFlagsProviderWrapper = makeMockedFeatureFlagsProviderWrapper(
+  makeMockedContextValue({}),
+);

package/src/featureFlags/useFeature.test.tsx

@@ -0,0 +1,23 @@
+import { renderHook } from "@testing-library/react-hooks";
+import useFeature from "./useFeature";
+import { makeMockedFeatureFlagsProviderWrapper, makeMockedContextValue } from "./mock";
+
+describe("useFeature hook", () => {
+  it("should return null if a flag is not defined remotely", () => {
+    const mockedFeatures = {};
+    const { result } = renderHook(() => useFeature("mockFeature"), {
+      wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+    });
+    expect(result.current).toBeNull();
+  });
+
+  it("should return the feature flag value if the feature flag is defined", () => {
+    const mockedFeatures = {
+      mockFeature: { enabled: true, params: { blabla: "hello" } },
+    };
+    const { result } = renderHook(() => useFeature("mockFeature"), {
+      wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+    });
+    expect(result.current).toBe(mockedFeatures.mockFeature);
+  });
+});

package/src/featureFlags/useFeature.ts

@@ -0,0 +1,21 @@
+import { useMemo } from "react";
+import { useFeatureFlags } from "./FeatureFlagsContext";
+import { FeatureId, Feature, FeatureParam } from "@ledgerhq/types-live";
+
+/**
+ * Hook that returns the value of a feature flag based on its `featureId`.
+ *
+ * @dev do not modify this function to make it return a default arbitrary value
+ * instead of null, this should not be handled at this level.
+ *
+ * @param featureId
+ * @returns a feature flag value or null if the feature flag is not found
+ * (neither in the remote configuration, in the cache or in the local defaults).
+ */
+const useFeature = <T extends FeatureId>(featureId: T): Feature<FeatureParam<T>> | null => {
+  const featureFlags = useFeatureFlags();
+  const value = useMemo(() => featureFlags.getFeature(featureId), [featureFlags, featureId]);
+  return value;
+};
+
+export default useFeature;

package/src/featureFlags/useHasOverriddenFeatureFlags.ts

@@ -0,0 +1,24 @@
+import { useMemo } from "react";
+import { FeatureId } from "@ledgerhq/types-live";
+import { useFeatureFlags } from "./FeatureFlagsContext";
+import { DEFAULT_FEATURES } from "./defaultFeatures";
+
+/**
+ *
+ * @returns whether one or more flags are locally overridden
+ */
+export function useHasLocallyOverriddenFeatureFlags(): boolean {
+  const { getFeature } = useFeatureFlags();
+  return useMemo(
+    () =>
+      Object.entries(DEFAULT_FEATURES).some(([featureId]) => {
+        try {
+          const val = getFeature(featureId as FeatureId);
+          return val?.overridesRemote || val?.overriddenByEnv;
+        } catch (e) {
+          return false;
+        }
+      }),
+    [getFeature],
+  );
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./featureFlags";