@ledgerhq/live-common 25.2.0-next.0 → 26.0.0-next.2

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

@@ -31,10 +31,12 @@ const cache = makeBridgeCacheSystem({
   },
 });
 describe("cosmos/react", () => {
-  describe("useCosmosPreloadData", () => {
+  describe("useCosmosFamilyPreloadData", () => {
     it("should return Cosmos preload data and updates", async () => {
       const { prepare } = setup();
-      const { result } = renderHook(() => hooks.useCosmosPreloadData());
+      const { result } = renderHook(() =>
+        hooks.useCosmosFamilyPreloadData("cosmos")
+      );
       const data = getCurrentCosmosPreloadData();
       expect(result.current).toStrictEqual(data);
       await act(() => prepare());
@@ -46,7 +48,7 @@ describe("cosmos/react", () => {
       const { account, prepare } = setup();
       await prepare();
       const { result } = renderHook(() =>
-        hooks.useCosmosMappedDelegations(account)
+        hooks.useCosmosFamilyMappedDelegations(account)
       );
       const delegations = account.cosmosResources?.delegations;
       invariant(delegations, "cosmos: delegations is required");
@@ -72,13 +74,13 @@ describe("cosmos/react", () => {
         const { account, prepare } = setup();
         await prepare();
         const { result } = renderHook(() =>
-          hooks.useCosmosMappedDelegations(account, "claimReward")
+          hooks.useCosmosFamilyMappedDelegations(account, "claimReward")
         );
         expect(result.current.length).toBe(3);
       });
     });
   });
-  describe("useCosmosDelegationsQuerySelector", () => {
+  describe("useCosmosFamilyDelegationsQuerySelector", () => {
     it("should return delegations filtered by query as options", async () => {
       const { account, transaction, prepare } = setup();
       await prepare();
@@ -99,7 +101,10 @@ describe("cosmos/react", () => {
         })),
       };
       const { result } = renderHook(() =>
-        hooks.useCosmosDelegationsQuerySelector(account, newTx as Transaction)
+        hooks.useCosmosFamilyDelegationsQuerySelector(
+          account,
+          newTx as Transaction
+        )
       );
       expect(result.current.options.length).toBe(delegations.length);
       act(() => {
@@ -125,7 +130,10 @@ describe("cosmos/react", () => {
         })),
       };
       const { result } = renderHook(() =>
-        hooks.useCosmosDelegationsQuerySelector(account, newTx as Transaction)
+        hooks.useCosmosFamilyDelegationsQuerySelector(
+          account,
+          newTx as Transaction
+        )
       );
       expect(
         (
@@ -134,7 +142,7 @@ describe("cosmos/react", () => {
         ).validatorAddress
       ).toBe(delegations[0].validatorAddress);
     });
-    it("should find delegation by cosmosSourceValidator field and return as value for redelegate", async () => {
+    it("should find delegation by sourceValidator field and return as value for redelegate", async () => {
       const { account, transaction, prepare } = setup();
       await prepare();
       invariant(
@@ -143,7 +151,7 @@ describe("cosmos/react", () => {
       );
       const delegations =
         (account.cosmosResources as CosmosResources).delegations || [];
-      const cosmosSourceValidator =
+      const sourceValidator =
         delegations[delegations.length - 1].validatorAddress;
       const newTx = {
         ...transaction,
@@ -152,17 +160,20 @@ describe("cosmos/react", () => {
           address: validatorAddress,
           amount,
         })),
-        cosmosSourceValidator,
+        sourceValidator,
       };
       const { result } = renderHook(() =>
-        hooks.useCosmosDelegationsQuerySelector(account, newTx as Transaction)
+        hooks.useCosmosFamilyDelegationsQuerySelector(
+          account,
+          newTx as Transaction
+        )
       );
       expect(
         (
           (result.current.value as CosmosMappedDelegation)
             .validator as CosmosValidatorItem
         ).validatorAddress
-      ).toBe(cosmosSourceValidator);
+      ).toBe(sourceValidator);
     });
   });
   describe("useSortedValidators", () => {
@@ -170,7 +181,7 @@ describe("cosmos/react", () => {
       const { account, prepare } = setup();
       await prepare();
       const { result: preloadDataResult } = renderHook(() =>
-        hooks.useCosmosPreloadData()
+        hooks.useCosmosFamilyPreloadData("cosmos")
       );
       const { validators } = preloadDataResult.current;
       const delegations = (account.cosmosResources?.delegations || []).map(
@@ -192,7 +203,7 @@ describe("cosmos/react", () => {
   describe("reorderValidators", () => {
     it("should return a list of Validators with Ledger first", () => {
       const { result } = renderHook(() =>
-        hooks.useLedgerFirstShuffledValidatorsCosmos()
+        hooks.useLedgerFirstShuffledValidatorsCosmosFamily("cosmos")
       );
       expect(result.current[0].validatorAddress).toBe(LEDGER_VALIDATOR_ADDRESS);
     });

package/src/families/cosmos/react.ts

@@ -25,20 +25,52 @@ import { getAccountUnit } from "../../account";
 import useMemoOnce from "../../hooks/useMemoOnce";
 import { LEDGER_VALIDATOR_ADDRESS } from "./utils";
 
-export function useCosmosPreloadData(): CosmosPreloadData {
-  const [state, setState] = useState(getCurrentCosmosPreloadData);
+// Add Cosmos-families imports below:
+import {
+  getCurrentOsmosisPreloadData,
+  getOsmosisPreloadDataUpdates,
+} from "../osmosis/preloadedData";
+import { LEDGER_OSMOSIS_VALIDATOR_ADDRESS } from "../osmosis/utils";
+
+export function useCosmosFamilyPreloadData(
+  currencyName: string
+): CosmosPreloadData {
+  let getCurrent;
+  let getUpdates;
+
+  if (currencyName == "cosmos") {
+    getCurrent = getCurrentCosmosPreloadData;
+    getUpdates = getCosmosPreloadDataUpdates;
+  }
+  if (currencyName == "osmosis") {
+    getCurrent = getCurrentOsmosisPreloadData;
+    getUpdates = getOsmosisPreloadDataUpdates;
+  }
+
+  const [state, setState] = useState(getCurrent);
   useEffect(() => {
-    const sub = getCosmosPreloadDataUpdates().subscribe(setState);
+    const sub = getUpdates().subscribe(setState);
     return () => sub.unsubscribe();
-  }, []);
+  }, [getCurrent, getUpdates]);
   return state;
 }
 
-export function useCosmosMappedDelegations(
+// export function useCosmosPreloadData(): CosmosPreloadData {
+//   const [state, setState] = useState(getCurrentCosmosPreloadData);
+//   useEffect(() => {
+//     const sub = getCosmosPreloadDataUpdates().subscribe(setState);
+//     return () => sub.unsubscribe();
+//   }, []);
+//   return state;
+// }
+
+export function useCosmosFamilyMappedDelegations(
   account: CosmosAccount,
   mode?: CosmosOperationMode
 ): CosmosMappedDelegation[] {
-  const { validators } = useCosmosPreloadData();
+  const currencyName = account.currency.name.toLowerCase();
+  const { validators } = useCosmosFamilyPreloadData(currencyName);
+
   const delegations = account.cosmosResources?.delegations;
   invariant(delegations, "cosmos: delegations is required");
   const unit = getAccountUnit(account);
@@ -54,7 +86,7 @@ export function useCosmosMappedDelegations(
   }, [delegations, validators, mode, unit]);
 }
 
-export function useCosmosDelegationsQuerySelector(
+export function useCosmosFamilyDelegationsQuerySelector(
   account: CosmosAccount,
   transaction: Transaction,
   delegationSearchFilter: CosmosSearchFilter = defaultSearchFilter
@@ -65,7 +97,10 @@ export function useCosmosDelegationsQuerySelector(
   value: CosmosMappedDelegation | null | undefined;
 } {
   const [query, setQuery] = useState<string>("");
-  const delegations = useCosmosMappedDelegations(account, transaction.mode);
+  const delegations = useCosmosFamilyMappedDelegations(
+    account,
+    transaction.mode
+  );
   const options = useMemo<CosmosMappedDelegation[]>(
     () => delegations.filter(delegationSearchFilter(query)),
     [query, delegations, delegationSearchFilter]
@@ -75,12 +110,12 @@ export function useCosmosDelegationsQuerySelector(
     switch (transaction.mode) {
       case "redelegate":
         invariant(
-          transaction.cosmosSourceValidator,
-          "cosmos: cosmosSourceValidator is required"
+          transaction.sourceValidator,
+          "cosmos: sourceValidator is required"
         );
         return options.find(
           ({ validatorAddress }) =>
-            validatorAddress === transaction.cosmosSourceValidator
+            validatorAddress === transaction.sourceValidator
         );
 
       default:
@@ -143,6 +178,7 @@ export function useSortedValidators(
   return sr;
 }
 
+// Nothing using this function?
 export function useMappedExtraOperationDetails({
   account,
   extra,
@@ -150,7 +186,7 @@ export function useMappedExtraOperationDetails({
   account: CosmosAccount;
   extra: CosmosExtraTxInfo;
 }): CosmosExtraTxInfo {
-  const { validators } = useCosmosPreloadData();
+  const { validators } = useCosmosFamilyPreloadData("cosmos");
   const unit = getAccountUnit(account);
   return {
     validators: extra.validators
@@ -159,24 +195,40 @@ export function useMappedExtraOperationDetails({
     validator: extra.validator
       ? mapDelegationInfo([extra.validator], validators, unit)[0]
       : undefined,
-    cosmosSourceValidator: extra.cosmosSourceValidator
-      ? extra.cosmosSourceValidator
-      : undefined,
+    sourceValidator: extra.sourceValidator ? extra.sourceValidator : undefined,
+    autoClaimedRewards:
+      extra.autoClaimedRewards != null
+        ? extra.autoClaimedRewards
+        : "empty string",
   };
 }
 
-export function useLedgerFirstShuffledValidatorsCosmos(
+export function useLedgerFirstShuffledValidatorsCosmosFamily(
+  currencyName: string,
   searchInput?: string
 ): CosmosValidatorItem[] {
-  const data = useCosmosPreloadData();
+  let data;
+  let ledgerValidatorAddress;
+  if (currencyName == "osmosis") {
+    data = getCurrentOsmosisPreloadData();
+    ledgerValidatorAddress = LEDGER_OSMOSIS_VALIDATOR_ADDRESS;
+  } else {
+    data = getCurrentCosmosPreloadData();
+    ledgerValidatorAddress = LEDGER_VALIDATOR_ADDRESS;
+  }
 
   return useMemo(() => {
-    return reorderValidators(data?.validators ?? [], searchInput);
-  }, [data, searchInput]);
+    return reorderValidators(
+      data?.validators ?? [],
+      ledgerValidatorAddress,
+      searchInput
+    );
+  }, [data, ledgerValidatorAddress, searchInput]);
 }
 
 function reorderValidators(
   validators: CosmosValidatorItem[],
+  ledgerValidatorAddress: string,
   searchInput?: string
 ): CosmosValidatorItem[] {
   const sortedValidators = validators
@@ -190,12 +242,12 @@ function reorderValidators(
 
   // move Ledger validator to the first position
   const ledgerValidator = sortedValidators.find(
-    (v) => v.validatorAddress === LEDGER_VALIDATOR_ADDRESS
+    (v) => v.validatorAddress === ledgerValidatorAddress
   );
 
   if (ledgerValidator) {
     const sortedValidatorsLedgerFirst = sortedValidators.filter(
-      (v) => v.validatorAddress !== LEDGER_VALIDATOR_ADDRESS
+      (v) => v.validatorAddress !== ledgerValidatorAddress
     );
     sortedValidatorsLedgerFirst.unshift(ledgerValidator);
 

package/src/families/cosmos/specs.ts

@@ -308,7 +308,7 @@ const cosmos: AppSpec<Transaction> = {
             {
               mode: "redelegate",
               memo: "LedgerLiveBot",
-              cosmosSourceValidator: (sourceDelegation as CosmosDelegation)
+              sourceValidator: (sourceDelegation as CosmosDelegation)
                 .validatorAddress,
               validators: [
                 {
@@ -341,7 +341,7 @@ const cosmos: AppSpec<Transaction> = {
               .find(
                 (d) =>
                   d.validatorDstAddress === v.address &&
-                  d.validatorSrcAddress === transaction.cosmosSourceValidator
+                  d.validatorSrcAddress === transaction.sourceValidator
               );
             invariant(d, "redelegated %s must be found in account", v.address);
             expect({

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

@@ -31,8 +31,7 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
     {
       title: "Validator Source",
       button: "Rr",
-      expectedValue: ({ transaction }) =>
-        transaction.cosmosSourceValidator || "",
+      expectedValue: ({ transaction }) => transaction.sourceValidator || "",
     },
     {
       title: "Validator Dest",

package/src/families/cosmos/transaction.ts

@@ -19,7 +19,7 @@ export const formatTransaction = (
     recipient,
     validators,
     memo,
-    cosmosSourceValidator,
+    sourceValidator,
     useAllAmount,
   }: Transaction,
   account: Account
@@ -50,9 +50,7 @@ ${
             v.address
         )
         .join("\n")
-}${
-  !cosmosSourceValidator ? "" : "\n  source validator=" + cosmosSourceValidator
-}
+}${!sourceValidator ? "" : "\n  source validator=" + sourceValidator}
 with fees=${fees ? formatCurrencyUnit(getAccountUnit(account), fees) : "?"}${
   !memo ? "" : `\n  memo=${memo}`
 }`;
@@ -71,7 +69,7 @@ export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
     fees: tr.fees ? new BigNumber(tr.fees) : null,
     gas: tr.gas ? new BigNumber(tr.gas) : null,
     memo: tr.memo,
-    cosmosSourceValidator: tr.cosmosSourceValidator,
+    sourceValidator: tr.sourceValidator,
     validators: tr.validators
       ? tr.validators.map((v) => ({ ...v, amount: new BigNumber(v.amount) }))
       : [],
@@ -92,7 +90,7 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
     fees: t.fees ? t.fees.toString() : null,
     gas: t.gas ? t.gas.toString() : null,
     memo: t.memo,
-    cosmosSourceValidator: t.cosmosSourceValidator,
+    sourceValidator: t.sourceValidator,
     validators: t.validators
       ? t.validators.map((v) => ({ ...v, amount: v.amount.toString() }))
       : [],

package/src/families/cosmos/types.ts

@@ -102,14 +102,25 @@ export type CosmosOperationMode =
   | "redelegate"
   | "claimReward"
   | "claimRewardCompound";
-export type NetworkInfo = {
-  family: "cosmos";
+
+export type CosmosLikeNetworkInfo = {
+  family: string;
   fees: BigNumber;
 };
-export type NetworkInfoRaw = {
-  family: "cosmos";
+
+export type CosmosLikeNetworkInfoRaw = {
+  family: string;
   fees: string;
 };
+
+export type NetworkInfo = CosmosLikeNetworkInfo & {
+  family: "cosmos";
+};
+
+export type NetworkInfoRaw = CosmosLikeNetworkInfoRaw & {
+  family: "cosmos";
+};
+
 export type CosmosOperation = Operation & {
   extra: CosmosExtraTxInfo;
 };
@@ -118,38 +129,55 @@ export type CosmosOperationRaw = OperationRaw & {
 };
 export type CosmosExtraTxInfo = {
   validators?: CosmosDelegationInfo[];
-  cosmosSourceValidator?: string | null | undefined;
+  sourceValidator?: string | null | undefined;
   validator?: CosmosDelegationInfo;
+  autoClaimedRewards?: string | null | undefined; // this is experimental to better represent auto claimed rewards
 };
 
 export type CosmosDelegationInfo = {
   address: string;
   amount: BigNumber;
 };
+
 export type CosmosDelegationInfoRaw = {
   address: string;
   amount: string;
 };
 
-export type Transaction = TransactionCommon & {
-  family: "cosmos";
+export type CosmosClaimedRewardInfo = {
+  amount: BigNumber;
+};
+
+export type CosmosLikeTransaction = TransactionCommon & {
+  family: string;
   mode: CosmosOperationMode;
-  networkInfo: NetworkInfo | null | undefined;
+  networkInfo: CosmosLikeNetworkInfo | null | undefined;
   fees: BigNumber | null | undefined;
   gas: BigNumber | null | undefined;
   memo: string | null | undefined;
   validators: CosmosDelegationInfo[];
-  cosmosSourceValidator: string | null | undefined;
+  sourceValidator: string | null | undefined;
 };
-export type TransactionRaw = TransactionCommonRaw & {
-  family: "cosmos";
+
+export type Transaction = CosmosLikeTransaction & {
+  family: "cosmos" | "osmosis";
+  networkInfo: NetworkInfo | null | undefined;
+};
+
+export type CosmosLikeTransactionRaw = TransactionCommonRaw & {
+  family: string;
   mode: CosmosOperationMode;
-  networkInfo: NetworkInfoRaw | null | undefined;
+  networkInfo: CosmosLikeNetworkInfoRaw | null | undefined;
   fees: string | null | undefined;
   gas: string | null | undefined;
   memo: string | null | undefined;
   validators: CosmosDelegationInfoRaw[];
-  cosmosSourceValidator: string | null | undefined;
+  sourceValidator: string | null | undefined;
+};
+
+export type TransactionRaw = CosmosLikeTransactionRaw & {
+  family: "cosmos" | "osmosis";
+  networkInfo: NetworkInfoRaw | null | undefined;
 };
 
 export type StatusErrorMap = {

package/src/families/cosmos/utils.ts

@@ -1,2 +1,10 @@
+// Import here other Cosmos-based Ledger Validators
+import { LEDGER_OSMOSIS_VALIDATOR_ADDRESS } from "../osmosis/utils";
+
 export const LEDGER_VALIDATOR_ADDRESS =
   "cosmosvaloper10wljxpl03053h9690apmyeakly3ylhejrucvtm";
+
+export const COSMOS_FAMILY_LEDGER_VALIDATOR_ADDRESSES = [
+  LEDGER_VALIDATOR_ADDRESS,
+  LEDGER_OSMOSIS_VALIDATOR_ADDRESS,
+];