@ledgerhq/live-common 34.50.0 → 34.51.0-nightly.0

package/src/exchange/swap/postSwapState.ts

@@ -7,14 +7,14 @@ import { getSwapAPIBaseURL, getSwapUserIP } from ".";
 
 function createSwapIntentHashes({
   provider,
-  fromAccountId,
-  toAccountId,
-  amount,
+  fromAccountAddress,
+  toAccountAddress,
+  fromAmount,
 }: {
   provider: string;
-  fromAccountId?: string;
-  toAccountId?: string;
-  amount?: string;
+  fromAccountAddress?: string;
+  toAccountAddress?: string;
+  fromAmount?: string;
 }) {
   // for example '2025-08-01' used to add a one day unique nonce to the swap intent hash
   const currentday = new Date().toISOString().split("T")[0];
@@ -24,9 +24,9 @@ function createSwapIntentHashes({
     .update(
       JSON.stringify({
         provider,
-        fromAccountId,
-        toAccountId,
-        amount,
+        fromAccountAddress,
+        toAccountAddress,
+        fromAmount,
         currentday,
       }),
     )
@@ -36,9 +36,9 @@ function createSwapIntentHashes({
     .createHash("sha256")
     .update(
       JSON.stringify({
-        fromAccountId,
-        toAccountId,
-        amount,
+        fromAccountAddress,
+        toAccountAddress,
+        fromAmount,
         currentday,
       }),
     )
@@ -52,9 +52,9 @@ export const postSwapAccepted: PostSwapAccepted = async ({
   swapId = "",
   transactionId,
   swapAppVersion,
-  fromAccountId,
-  toAccountId,
-  amount,
+  fromAccountAddress,
+  toAccountAddress,
+  fromAmount,
   ...rest
 }) => {
   if (isIntegrationTestEnv())
@@ -70,9 +70,9 @@ export const postSwapAccepted: PostSwapAccepted = async ({
 
   const { swapIntentWithProvider, swapIntentWithoutProvider } = createSwapIntentHashes({
     provider,
-    fromAccountId,
-    toAccountId,
-    amount,
+    fromAccountAddress,
+    toAccountAddress,
+    fromAmount,
   });
 
   try {
@@ -99,9 +99,9 @@ export const postSwapCancelled: PostSwapCancelled = async ({
   provider,
   swapId = "",
   swapAppVersion,
-  fromAccountId,
-  toAccountId,
-  amount,
+  fromAccountAddress,
+  toAccountAddress,
+  fromAmount,
   seedIdFrom,
   seedIdTo,
   refundAddress,
@@ -120,19 +120,14 @@ export const postSwapCancelled: PostSwapCancelled = async ({
 
   const { swapIntentWithProvider, swapIntentWithoutProvider } = createSwapIntentHashes({
     provider,
-    fromAccountId,
-    toAccountId,
-    amount,
+    fromAccountAddress,
+    toAccountAddress,
+    fromAmount,
   });
 
   // Check if the refundAddress and payoutAddress match the account addresses, just to eliminate this supposition
   const payloadAddressMatchAccountAddress =
-    fromAccountId &&
-    toAccountId &&
-    refundAddress &&
-    payoutAddress &&
-    fromAccountId.includes(refundAddress) &&
-    toAccountId.includes(payoutAddress);
+    fromAccountAddress === refundAddress && toAccountAddress === payoutAddress;
 
   try {
     const ipHeader = getSwapUserIP();
@@ -151,8 +146,9 @@ export const postSwapCancelled: PostSwapCancelled = async ({
       swapIntentWithProvider,
       swapIntentWithoutProvider,
       payloadAddressMatchAccountAddress,
-      fromAccountId: shouldIncludeAddresses ? fromAccountId : undefined,
-      toAccountId: shouldIncludeAddresses ? toAccountId : undefined,
+      fromAmount,
+      fromAccountAddress: shouldIncludeAddresses ? fromAccountAddress : undefined,
+      toAccountAddress: shouldIncludeAddresses ? toAccountAddress : undefined,
       payloadRefundAddress: shouldIncludeAddresses ? refundAddress : undefined,
       payloadPayoutAddress: shouldIncludeAddresses ? payoutAddress : undefined,
       maybeSeedMatch: seedIdFrom === seedIdTo, // Only true if both accounts are from the same seed and from the same chain type

package/src/exchange/swap/setBroadcastTransaction.ts

@@ -12,9 +12,9 @@ export const setBroadcastTransaction = ({
   hardwareWalletType,
   swapType,
   swapAppVersion,
-  fromAccountId,
-  toAccountId,
-  amount,
+  fromAccountAddress,
+  toAccountAddress,
+  fromAmount,
 }: {
   result: { operation: Operation | string; swapId: string };
   provider: string;
@@ -23,9 +23,9 @@ export const setBroadcastTransaction = ({
   hardwareWalletType?: DeviceModelId;
   swapType?: TradeMethod;
   swapAppVersion?: string;
-  fromAccountId?: string;
-  toAccountId?: string;
-  amount?: string;
+  fromAccountAddress?: string;
+  toAccountAddress?: string;
+  fromAmount?: string;
 }) => {
   const { operation, swapId } = result;
 
@@ -45,9 +45,9 @@ export const setBroadcastTransaction = ({
       hardwareWalletType,
       swapType: swapType,
       swapAppVersion,
-      fromAccountId,
-      toAccountId,
-      amount,
+      fromAccountAddress,
+      toAccountAddress,
+      fromAmount,
     });
   } else {
     postSwapAccepted({
@@ -59,9 +59,9 @@ export const setBroadcastTransaction = ({
       hardwareWalletType,
       swapType,
       swapAppVersion,
-      fromAccountId,
-      toAccountId,
-      amount,
+      fromAccountAddress,
+      toAccountAddress,
+      fromAmount,
     });
   }
 };

package/src/exchange/swap/types.ts

@@ -200,9 +200,9 @@ type SwapStateRequest = {
   hardwareWalletType: DeviceModelId;
   swapType: TradeMethod;
   swapAppVersion?: string;
-  fromAccountId?: string;
-  toAccountId?: string;
-  amount?: string;
+  fromAccountAddress?: string;
+  toAccountAddress?: string;
+  fromAmount?: string;
   seedIdFrom?: string;
   seedIdTo?: string;
   refundAddress?: string;

package/src/exchange/swap/updateAccountSwapStatus.ts

@@ -4,6 +4,8 @@ import type { TokenAccount, Account, SwapOperation, Operation } from "@ledgerhq/
 import type { SwapStatus, SwapStatusRequest, UpdateAccountSwapStatus } from "./types";
 import { log } from "@ledgerhq/logs";
 
+const PROVIDERS_REQUIRING_OPERATION_ID = ["thorswap", "lifi", "nearintents"];
+
 const maybeGetUpdatedSwapHistory = async (
   swapHistory: SwapOperation[] | null | undefined,
   operations: Operation[] | null | undefined,
@@ -38,15 +40,15 @@ const maybeGetUpdatedSwapHistory = async (
           }
         } else {
           // Collect all others swaps that need status update via getMultipleStatus
-          const transactionId =
-            provider === "thorswap" || provider === "lifi"
-              ? operations?.find(o => o.id.includes(operationId))?.hash
-              : undefined;
+          const requiresOperationId = PROVIDERS_REQUIRING_OPERATION_ID.includes(provider);
+          const relatedTransactionId = requiresOperationId
+            ? operations?.find(op => op.id.includes(operationId))?.hash
+            : undefined;
           pendingSwapIds.push({
             provider,
             swapId,
-            transactionId,
-            ...((provider === "thorswap" || provider === "lifi") && { operationId }),
+            transactionId: relatedTransactionId,
+            ...(requiresOperationId && { operationId }),
           });
         }
       }

package/src/families/canton/config.ts

@@ -7,8 +7,8 @@ export const cantonConfig: Record<string, ConfigInfo> = {
       status: {
         type: "active",
       },
-      nodeUrl: "https://canton-gateway.api.live.ledger.com/v1/node/ledger-mainnet-prd",
-      nodeId: "ledger-live-mainnet-prd",
+      nodeUrl: "https://canton-gateway.api.live.ledger.com/v1/node/ledger-live-mainnet",
+      nodeId: "ledger-live-mainnet",
       gatewayUrl: "https://canton-gateway.api.live.ledger.com",
       minReserve: 0,
       useGateway: true,
@@ -22,8 +22,8 @@ export const cantonConfig: Record<string, ConfigInfo> = {
       status: {
         type: "active",
       },
-      nodeUrl: "https://wallet-validator-devnet-canton.ledger-test.com",
-      nodeId: "ledger-devnet-stg",
+      nodeUrl: "https://canton-gateway.api.live.ledger.com/v1/node/ledger-live-devnet",
+      nodeId: "ledger-live-devnet",
       gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
       minReserve: 0,
       useGateway: true,
@@ -31,19 +31,19 @@ export const cantonConfig: Record<string, ConfigInfo> = {
       nativeInstrumentId: "Amulet",
     },
   },
-  config_currency_canton_network_localnet: {
+  config_currency_canton_network_testnet: {
     type: "object",
     default: {
       status: {
         type: "active",
       },
-      nodeUrl: "http://localhost:2975/v2",
-      nodeId: undefined,
-      gatewayUrl: undefined,
+      nodeUrl: "https://canton-gateway.api.live.ledger.com/v1/node/ledger-live-testnet",
+      nodeId: "ledger-live-testnet",
+      gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
       minReserve: 0,
-      useGateway: false,
-      networkType: "localnet",
       nativeInstrumentId: "Amulet",
+      useGateway: true,
+      networkType: "testnet",
     },
   },
 };

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

@@ -0,0 +1,25 @@
+import shouldUseReceiveOptions from "./shouldUseReceiveOptions";
+
+describe("shouldUseReceiveOptions", () => {
+  it("returns true for 'ethereum/erc20/usd__coin'", () => {
+    expect(shouldUseReceiveOptions("ethereum/erc20/usd__coin")).toBe(true);
+  });
+
+  it("returns true for 'ethereum'", () => {
+    expect(shouldUseReceiveOptions("ethereum")).toBe(true);
+  });
+
+  it("returns false for undefined", () => {
+    expect(shouldUseReceiveOptions(undefined)).toBe(false);
+  });
+
+  it("returns false for empty string", () => {
+    expect(shouldUseReceiveOptions("")).toBe(false);
+  });
+
+  it("returns false for other currency ids", () => {
+    expect(shouldUseReceiveOptions("bitcoin")).toBe(false);
+    expect(shouldUseReceiveOptions("ethereum/erc20/other_token")).toBe(false);
+    expect(shouldUseReceiveOptions("usd__coin")).toBe(false);
+  });
+});

package/src/families/evm/shouldUseReceiveOptions.ts

@@ -0,0 +1,4 @@
+const shouldUseReceiveOptions = (currencyId: string | undefined) =>
+  !!(currencyId && ["ethereum/erc20/usd__coin", "ethereum"].includes(currencyId));
+
+export default shouldUseReceiveOptions;

package/src/families/hedera/exchange.ts

@@ -0,0 +1,48 @@
+import { LatestFirmwareVersionRequired, TransportStatusError } from "@ledgerhq/errors";
+import Exchange from "@ledgerhq/hw-app-exchange";
+import { loadPKI } from "@ledgerhq/hw-bolos";
+import calService from "@ledgerhq/ledger-cal-service";
+import trustService from "@ledgerhq/ledger-trust-service";
+import { getEnv } from "@ledgerhq/live-env";
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import { Account } from "@ledgerhq/types-live";
+
+function isPKIUnsupportedError(err: unknown): err is TransportStatusError {
+  return err instanceof TransportStatusError && err.message.includes("0x6a81");
+}
+
+export async function handleHederaTrustedFlow({
+  exchange,
+  hederaAccount,
+  deviceModelId,
+}: {
+  exchange: Exchange;
+  hederaAccount: Account;
+  deviceModelId: DeviceModelId;
+}) {
+  const serviceEnv = getEnv("MOCK_EXCHANGE_TEST_CONFIG") ? "test" : "prod";
+
+  const cert = await calService.getCertificate(deviceModelId, "trusted_name", "latest", {
+    env: serviceEnv,
+    signatureKind: serviceEnv,
+  });
+
+  try {
+    await loadPKI(exchange.transport, "TRUSTED_NAME", cert.descriptor, cert.signature);
+  } catch (err) {
+    if (isPKIUnsupportedError(err)) {
+      throw new LatestFirmwareVersionRequired("LatestFirmwareVersionRequired");
+    }
+  }
+
+  const challenge = await exchange.getChallenge();
+  const hexChallenge = challenge.toString(16);
+
+  const trustServiceResult = await trustService.hedera.getPublicKey(
+    hederaAccount.freshAddress,
+    hexChallenge,
+  );
+  const signedDescriptorBuffer = Buffer.from(trustServiceResult.signedDescriptor, "hex");
+
+  await exchange.sendTrustedDescriptor(signedDescriptorBuffer);
+}

package/src/families/tezos/config.ts

@@ -22,8 +22,8 @@ export const tezosConfig: Record<string, ConfigInfo> = {
         minGasLimit: 600,
         minRevealGasLimit: 300,
         minStorageLimit: 0,
-        minFees: 500,
-        minEstimatedFees: 500,
+        minFees: 300,
+        minEstimatedFees: 300,
       },
     },
   },

package/src/families/tezos/react.ts

@@ -1,6 +1,6 @@
 import type { AccountLike } from "@ledgerhq/types-live";
 import { useEffect, useMemo, useState } from "react";
-import { Baker, Delegation } from "@ledgerhq/coin-tezos/types/index";
+import { Baker, Delegation, StakingPosition } from "@ledgerhq/coin-tezos/types/index";
 import { bakers } from "@ledgerhq/coin-tezos/network/index";
 
 export function useBakers(whitelistAddresses: string[]): Baker[] {
@@ -55,3 +55,22 @@ export function useRandomBaker(bakers: Baker[]): Baker {
   }, [bakers.length]);
   return bakers[randomBakerIndex];
 }
+
+export function useStakingPositions(account: AccountLike): StakingPosition[] {
+  const delegation = useDelegation(account);
+
+  return useMemo(() => {
+    if (account.type !== "Account" || !delegation?.address) return [];
+
+    return [
+      {
+        uid: account.freshAddress,
+        address: account.freshAddress,
+        delegate: delegation.address,
+        state: "active" as const,
+        asset: { type: "native" as const },
+        amount: BigInt(account.balance.toString()),
+      },
+    ];
+  }, [account, delegation]);
+}

package/src/families/tezos/setup.ts

@@ -1,24 +1,14 @@
 // Goal of this file is to inject all necessary device/signer dependency to coin-modules
 
 import { DerivationType, LedgerSigner } from "@taquito/ledger-signer";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import { TezosCoinConfig } from "@ledgerhq/coin-tezos/config";
-import { createBridges } from "@ledgerhq/coin-tezos/bridge/index";
-import type {
-  Transaction,
-  TezosSigner,
-  TransactionStatus,
-  TezosAccount,
-} from "@ledgerhq/coin-tezos/types/index";
+import type { TezosSigner } from "@ledgerhq/coin-tezos/types/index";
 import makeCliTools from "@ledgerhq/coin-tezos/test/cli";
 import type { CliTools } from "@ledgerhq/coin-tezos/test/cli";
 import tezosResolver from "@ledgerhq/coin-tezos/signer/index";
 import Xtz, { Curve } from "@ledgerhq/hw-app-tezos";
 import Transport from "@ledgerhq/hw-transport";
-import type { Bridge } from "@ledgerhq/types-live";
-import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
+import { createResolver, CreateSigner } from "../../bridge/setup";
 import { Resolver } from "../../hw/getAddress/types";
-import { getCurrencyConfiguration } from "../../config";
 
 const createSigner: CreateSigner<TezosSigner> = (transport: Transport) => {
   const xtz = new Xtz(transport);
@@ -46,17 +36,8 @@ const createSigner: CreateSigner<TezosSigner> = (transport: Transport) => {
   };
 };
 
-const getCurrencyConfig = (): TezosCoinConfig => {
-  return getCurrencyConfiguration(getCryptoCurrencyById("tezos"));
-};
-
-const bridge: Bridge<Transaction, TezosAccount, TransactionStatus> = createBridges(
-  executeWithSigner(createSigner),
-  getCurrencyConfig,
-);
-
 const resolver: Resolver = createResolver(createSigner, tezosResolver);
 
 const cliTools: CliTools = makeCliTools();
 
-export { bridge, cliTools, resolver };
+export { cliTools, resolver };

package/src/generated/bridge/js.ts

@@ -17,7 +17,6 @@ import { bridge as near } from "../../families/near/setup";
 import { bridge as polkadot } from "../../families/polkadot/setup";
 import { bridge as solana } from "../../families/solana/setup";
 import { bridge as stacks } from "../../families/stacks/setup";
-import { bridge as tezos } from "../../families/tezos/setup";
 import { bridge as ton } from "../../families/ton/setup";
 import { bridge as tron } from "../../families/tron/setup";
 import { bridge as vechain } from "../../families/vechain/setup";
@@ -44,7 +43,6 @@ export default {
   polkadot,
   solana,
   stacks,
-  tezos,
   ton,
   tron,
   vechain,

package/src/hw/actions/completeExchange.ts

@@ -3,6 +3,7 @@ import { scan, tap } from "rxjs/operators";
 import { useEffect, useState } from "react";
 import type { Action, Device } from "./types";
 import type { AppState } from "./app";
+import type { DeviceModelId } from "@ledgerhq/devices";
 import { log } from "@ledgerhq/logs";
 import { Exchange } from "../../exchange/types";
 import { Transaction } from "../../generated/types";
@@ -18,6 +19,7 @@ type State = {
 
 type CompleteExchangeState = AppState & State;
 type CompleteExchangeRequest = {
+  deviceModelId?: DeviceModelId;
   deviceId?: string;
   provider: string;
   transaction: Transaction;
@@ -130,6 +132,7 @@ export const createAction = (
         }),
         completeExchangeExec({
           deviceId: reduxDeviceFrozen?.deviceId,
+          deviceModelId: reduxDeviceFrozen?.modelId,
           provider,
           transaction,
           binaryPayload,

package/src/hw/signMessage/index.ts

@@ -13,6 +13,7 @@ import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
 import { withDevice } from "../deviceAccess";
 import type { SignMessage, Result } from "./types";
 import { messageSigner as ACREMessageSigner } from "../../families/bitcoin/ACRESetup";
+import { decodeAccountId } from "../../account";
 
 export const prepareMessageToSign = (account: Account, message: string): AnyMessage => {
   const utf8Message = Buffer.from(message, "hex").toString();
@@ -91,6 +92,15 @@ export const signMessageExec = ({ request, deviceId }: Input): Observable<Result
     throw new Error("account is required");
   }
 
+  const { type } = decodeAccountId(request.account.id);
+  if (type === "mock") {
+    return from(
+      Promise.resolve({
+        signature: "mockedSignature",
+      }),
+    );
+  }
+
   const result: Observable<Result> = withDevice(deviceId)(transport =>
     from(signMessage(transport, request.account!, request.message)),
   );

package/src/modularDrawer/hooks/modules/useLeftApyModule.tsx

@@ -1,7 +1,7 @@
 import React, { useMemo } from "react";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { ApyType } from "../../utils/type";
-import { useInterestRatesByCurrencies } from "../useInterestRatesByCurrencies";
+import { ApyType } from "../../../dada-client/types/trend";
+import { useInterestRatesByCurrencies } from "../../../dada-client/hooks/useInterestRatesByCurrencies";
 import { getInterestRateForAsset } from "../../utils/getInterestRateForAsset";
 
 const createApyItem = ({

package/src/modularDrawer/hooks/modules/useLeftMarketTrendModule.tsx

@@ -1,6 +1,6 @@
 import React, { useMemo } from "react";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { useMarketByCurrencies } from "../useMarketByCurrencies";
+import { useMarketByCurrencies } from "../../../dada-client/hooks/useMarketByCurrencies";
 
 const createMarketTrendItem = ({
   percent,

package/src/modularDrawer/hooks/modules/useRightMarketTrendModule.tsx

@@ -1,7 +1,7 @@
 import React, { useMemo } from "react";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { useMarketByCurrencies } from "../useMarketByCurrencies";
-import { counterValueFormatter } from "../../utils/counterValueFormatter";
+import { useMarketByCurrencies } from "../../../dada-client/hooks/useMarketByCurrencies";
+import counterValueFormatter from "../../../market/utils/countervalueFormatter";
 import { UseBalanceDeps } from "../../utils/type";
 
 const createMarketPriceItem = ({

package/src/modularDrawer/hooks/useAssetAccountCounts.tsx

@@ -24,13 +24,11 @@ export const useAssetAccountCounts = ({
   accountIds,
   formatLabel,
 }: AccountModuleParams): AssetCountItem[] =>
-  assets
-    .map(asset => {
-      const { length } = getAccountTuplesForCurrency(asset, nestedAccounts, accountIds);
-      return {
-        asset,
-        label: formatLabel(length),
-        count: length,
-      };
-    })
-    .sort((a, b) => b.count - a.count);
+  assets.map(asset => {
+    const { length } = getAccountTuplesForCurrency(asset, nestedAccounts, accountIds);
+    return {
+      asset,
+      label: formatLabel(length),
+      count: length,
+    };
+  });