@ledgerhq/live-common 34.49.0-nightly.6 → 34.50.0-nightly.0

package/src/bridge/generic-alpaca/signOperation.ts

@@ -96,9 +96,11 @@ export const genericSignOperation =
             assetOwner: transaction?.assetOwner || "",
             subAccountId: transaction.subAccountId || "",
             family: transaction.family,
+            feesStrategy: transaction.feesStrategy,
+            data: transaction.data,
           };
           const { amount } = await alpacaApi.validateIntent(
-            transactionToIntent(account, draftTransaction),
+            transactionToIntent(account, draftTransaction, alpacaApi.computeIntentType),
             { value: fees },
           );
           transaction.amount = new BigNumber(amount.toString());
@@ -107,7 +109,11 @@ export const genericSignOperation =
           const derivationPath = account.freshAddressPath;
           const { publicKey } = (await signer.getAddress(derivationPath)) as Result;
 
-          let transactionIntent = transactionToIntent(account, { ...transaction });
+          let transactionIntent = transactionToIntent(
+            account,
+            { ...transaction },
+            alpacaApi.computeIntentType,
+          );
           transactionIntent.senderPublicKey = publicKey;
 
           // Enrich with memo and asset information

package/src/bridge/generic-alpaca/signer/index.ts

@@ -1,12 +1,15 @@
 import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
 import stellarGetAddress from "@ledgerhq/coin-stellar/signer/getAddress";
 import Stellar from "@ledgerhq/hw-app-str";
-import { signTransaction, stellarSignTransaction } from "./signTransaction";
+import { signTransaction, stellarSignTransaction, tezosSignTransaction } from "./signTransaction";
 import { StrKey } from "@stellar/stellar-sdk";
 import { CreateSigner, executeWithSigner } from "../../setup";
 import Xrp from "@ledgerhq/hw-app-xrp";
 import Transport from "@ledgerhq/hw-transport";
 import { AlpacaSigner } from "./types";
+import { DerivationType, LedgerSigner as TaquitoLedgerSigner } from "@taquito/ledger-signer";
+import tezosGetAddress from "@ledgerhq/coin-tezos/signer/getAddress";
+import Tezos from "@ledgerhq/hw-app-tezos";
 
 const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
   return new Xrp(transport);
@@ -37,6 +40,39 @@ const createSignerStellar: CreateSigner<Stellar> = (transport: Transport) => {
 
 const signerContextStellar = executeWithSigner(createSignerStellar);
 
+const createSignerTezos: CreateSigner<
+  Tezos & { createLedgerSigner: (path: string, prompt: boolean, derivationType: number) => any }
+> = (transport: Transport) => {
+  const tezos = new Tezos(transport);
+  // align with genericSignOperation that calls signer.signTransaction
+  return Object.assign(tezos, {
+    async signTransaction(path: string, rawTxHex: string) {
+      const { signature } = await tezos.signOperation(path, rawTxHex, {});
+      return signature;
+    },
+    async getAddress(path: string, { verify }: { verify?: boolean } = {}) {
+      // Use Taquito LedgerSigner to retrieve base58 public key and matching pkh (like oldbridge)
+      const ledgerSigner = new TaquitoLedgerSigner(
+        transport,
+        path,
+        !!verify,
+        DerivationType.ED25519,
+      );
+      const address = await ledgerSigner.publicKeyHash();
+      const publicKey = await ledgerSigner.publicKey();
+      return { path, address, publicKey };
+    },
+    createLedgerSigner(path: string, prompt: boolean, derivationType: number) {
+      // Map 0 -> ED25519, 1 -> SECP256K1, 2 -> P256 by convention
+      let dt: DerivationType = DerivationType.ED25519;
+      if (derivationType === 1) dt = DerivationType.SECP256K1;
+      else if (derivationType === 2) dt = DerivationType.P256;
+      return new TaquitoLedgerSigner(transport, path, prompt, dt);
+    },
+  });
+};
+const signerContextTezos = executeWithSigner(createSignerTezos);
+
 export function getSigner(network: string): AlpacaSigner {
   switch (network) {
     case "ripple":
@@ -54,6 +90,13 @@ export function getSigner(network: string): AlpacaSigner {
         context: signerContextStellar,
       };
     }
+    case "tezos": {
+      return {
+        getAddress: tezosGetAddress(signerContextTezos),
+        signTransaction: tezosSignTransaction(executeWithSigner(createSignerTezos)),
+        context: signerContextTezos,
+      };
+    }
   }
   throw new Error(`signer for ${network} not implemented`);
 }

package/src/bridge/generic-alpaca/signer/signTransaction.ts

@@ -1,5 +1,6 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { StellarSigner } from "@ledgerhq/coin-stellar/types/signer";
+import { TezosSigner } from "@ledgerhq/coin-tezos/types/signer";
 import { LegacySigner, SignTransactionOptions } from "./types";
 
 export const signTransaction = <Signer extends LegacySigner>(
@@ -23,3 +24,12 @@ export const stellarSignTransaction = (signerContext: SignerContext<StellarSigne
     return signedTx.signature.toString("base64"); // It should return a Buffer
   };
 };
+
+export const tezosSignTransaction = (signerContext: SignerContext<TezosSigner>) => {
+  return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
+    const signed = await signerContext(deviceId, signer =>
+      signer.signOperation(path, rawTxHex, {}),
+    );
+    return signed.signature;
+  };
+};

package/src/bridge/generic-alpaca/tests/estimateMaxSpendable.test.ts

@@ -35,9 +35,23 @@ const dummyAccounts = [
     freshAddress: "s123",
     pendingOperations: [],
   },
+  {
+    id: "js:2:tezos:t123",
+    type: "Account",
+    spendableBalance: new BigNumber(50000000),
+    balance: new BigNumber(60000000),
+    currency: {
+      id: "tezos",
+      family: "tezos",
+      name: "Tezos",
+      units: [{ name: "XTZ", magnitude: 6 }],
+    },
+    freshAddress: "t123",
+    pendingOperations: [],
+  },
 ] as unknown as Account[];
 
-["xrp", "stellar"].forEach((currencyName, idx) => {
+["xrp", "stellar", "tezos"].forEach((currencyName, idx) => {
   describe(`genericEstimateMaxSpendable for ${currencyName}`, () => {
     const dummyAccount = dummyAccounts[idx];
 

package/src/bridge/generic-alpaca/tests/prepareTransaction.test.ts

@@ -49,6 +49,7 @@ describe("genericPrepareTransaction", () => {
     expect(transactionToIntent).toHaveBeenCalledWith(
       account,
       expect.objectContaining(baseTransaction),
+      undefined,
     );
   });
 

package/src/bridge/generic-alpaca/tests/signOperation.test.ts

@@ -14,7 +14,7 @@ jest.mock("../utils", () => ({
   transactionToIntent: jest.fn(),
 }));
 describe("genericSignOperation", () => {
-  const networks = ["xrp", "stellar"];
+  const networks = ["xrp", "stellar", "tezos"];
   const kind = "local";
 
   const mockSignerContext = jest.fn();
@@ -83,7 +83,7 @@ describe("genericSignOperation", () => {
         },
       });
 
-      expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
+      expect(transactionToIntent).toHaveBeenCalledWith(account, transaction, undefined);
       expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
     });
 

package/src/bridge/generic-alpaca/types.ts

@@ -9,14 +9,25 @@ type NetworkInfo = {
 export type GenericTransaction = TransactionCommon & {
   family: string;
   fees?: BigNumber | null;
+  storageLimit?: BigNumber | null;
   customFees?: {
-    parameters: { fees?: BigNumber | null };
+    parameters: { fees?: BigNumber | null; storageLimit?: BigNumber | null };
   };
   tag?: number | null | undefined;
   feeCustomUnit?: Unit | null | undefined;
   memoType?: string | null;
   memoValue?: string | null;
-  mode?: "send" | "changeTrust" | "send-legacy" | "send-eip1559";
+  data?: Buffer;
+  mode?:
+    | "send"
+    | "changeTrust"
+    | "send-legacy"
+    | "send-eip1559"
+    | "delegate"
+    | "stake"
+    | "undelegate"
+    | "unstake";
+  type?: number;
   assetReference?: string;
   assetOwner?: string;
   networkInfo?: NetworkInfo | null;

package/src/bridge/generic-alpaca/utils.test.ts

@@ -2,11 +2,76 @@ import {
   adaptCoreOperationToLiveOperation,
   extractBalance,
   findCryptoCurrencyByNetwork,
+  transactionToIntent,
 } from "./utils";
 import BigNumber from "bignumber.js";
 import { Operation as CoreOperation } from "@ledgerhq/coin-framework/api/types";
+import { Account } from "@ledgerhq/types-live";
+import { GenericTransaction } from "./types";
 
 describe("Alpaca utils", () => {
+  describe("transactionToIntent", () => {
+    describe("type", () => {
+      it("fallbacks to 'Payment' without a transaction mode", () => {
+        expect(
+          transactionToIntent(
+            { currency: { name: "ethereum", units: [{}] } } as Account,
+            { mode: undefined } as GenericTransaction,
+          ),
+        ).toMatchObject({
+          type: "Payment",
+        });
+      });
+
+      it.each([
+        ["changeTrust", "changeTrust"],
+        ["send", "send"],
+        ["send-legacy", "send-legacy"],
+        ["send-eip1559", "send-eip1559"],
+        ["stake", "stake"],
+        ["unstake", "unstake"],
+        ["delegate", "stake"],
+        ["undelegate", "unstake"],
+      ])(
+        "by default, associates '%s' transaction mode to '%s' intent type",
+        (mode, expectedType) => {
+          expect(
+            transactionToIntent(
+              { currency: { name: "ethereum", units: [{}] } } as Account,
+              { mode } as GenericTransaction,
+            ),
+          ).toMatchObject({
+            type: expectedType,
+          });
+        },
+      );
+
+      it("rejects other modes", () => {
+        expect(() =>
+          transactionToIntent(
+            { currency: { name: "ethereum", units: [{}] } } as Account,
+            { mode: "any" as unknown } as GenericTransaction,
+          ),
+        ).toThrow("Unsupported transaction mode: any");
+      });
+
+      it("supersedes the logic with a custom function", () => {
+        const computeIntentType = (transaction: GenericTransaction) =>
+          transaction.mode === "send" && transaction.type === 2 ? "send-eip1559" : "send-legacy";
+
+        expect(
+          transactionToIntent(
+            { currency: { name: "ethereum", units: [{}] } } as Account,
+            { mode: "send", type: 2 } as GenericTransaction,
+            computeIntentType,
+          ),
+        ).toMatchObject({
+          type: "send-eip1559",
+        });
+      });
+    });
+  });
+
   describe("findCryptoCurrencyByNetwork", () => {
     it("finds a crypto currency by id", () => {
       expect(findCryptoCurrencyByNetwork("ethereum")).toMatchObject({

package/src/bridge/generic-alpaca/utils.ts

@@ -78,6 +78,25 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
   return res;
 }
 
+/**
+ * Default implementation of `computeIntentType` is a simple whitelist
+ * with a fallback to "Payment"
+ */
+function defaultComputeIntentType(transaction: GenericTransaction): string {
+  if (!transaction.mode) return "Payment"; // NOTE: assuming payment by default here, can be changed based on transaction.mode
+
+  const modeRemap = {
+    delegate: "stake",
+    undelegate: "unstake",
+  };
+  const mode = modeRemap[transaction.mode] ?? transaction.mode;
+
+  if (["changeTrust", "send", "send-legacy", "send-eip1559", "stake", "unstake"].includes(mode))
+    return mode;
+
+  throw new Error(`Unsupported transaction mode: ${transaction.mode}`);
+}
+
 /**
  * Converts a transaction object into a `TransactionIntent` object, which is used to represent
  * the intent of a transaction in a standardized format.
@@ -92,6 +111,7 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
  *   - `fees` (optional): The fees associated with the transaction.
  *   - `memoType` (optional): The type of memo to attach to the transaction.
  *   - `memoValue` (optional): The value of the memo to attach to the transaction.
+ * @param computeIntentType - An optional function to compute the intent type that supersedes the default implementation if present
  *
  * @returns A `TransactionIntent` object containing the standardized representation of the transaction.
  *   - Includes details such as type, sender, recipient, amount, fees, asset, and an optional memo.
@@ -103,41 +123,34 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
 export function transactionToIntent(
   account: Account,
   transaction: GenericTransaction,
-): TransactionIntent<any> & { memo?: { type: string; value?: string } } {
-  let transactionType = "Payment"; // NOTE: assuming payment by default here, can be changed based on transaction.mode
-  if (transaction.mode) {
-    switch (transaction.mode) {
-      case "changeTrust":
-        transactionType = "changeTrust";
-        break;
-      case "send":
-        transactionType = "send";
-        break;
-      case "send-legacy":
-        transactionType = "send-legacy";
-        break;
-      case "send-eip1559":
-        transactionType = "send-eip1559";
-        break;
-      default:
-        throw new Error(`Unsupported transaction mode: ${transaction.mode}`);
-    }
-  }
-  const res: TransactionIntent & { memo?: { type: string; value?: string } } = {
-    type: transactionType,
+  computeIntentType?: (transaction: GenericTransaction) => string,
+): TransactionIntent & { memo?: { type: string; value?: string } } & {
+  data?: { type: string; value?: unknown };
+} {
+  const intentType = (computeIntentType ?? defaultComputeIntentType)(transaction);
+  const isStaking = ["stake", "unstake"].includes(intentType);
+  const amount = isStaking ? 0n : fromBigNumberToBigInt(transaction.amount, 0n);
+  const useAllAmount = isStaking || !!transaction.useAllAmount;
+  const res: TransactionIntent & { memo?: { type: string; value?: string } } & {
+    data?: { type: string; value?: unknown };
+  } = {
+    type: intentType,
     sender: account.freshAddress,
     recipient: transaction.recipient,
-    amount: fromBigNumberToBigInt(transaction.amount, BigInt(0)),
+    amount,
     asset: { type: "native", name: account.currency.name, unit: account.currency.units[0] },
-    useAllAmount: !!transaction.useAllAmount,
+    useAllAmount,
+    feesStrategy:
+      transaction.feesStrategy === "custom" ? undefined : transaction.feesStrategy ?? undefined,
+    data: Buffer.isBuffer(transaction.data)
+      ? { type: "buffer", value: transaction.data }
+      : { type: "none" },
   };
   if (transaction.assetReference && transaction.assetOwner) {
     const { subAccountId } = transaction;
     const { subAccounts } = account;
 
-    const tokenAccount = !subAccountId
-      ? null
-      : subAccounts && subAccounts.find(ta => ta.id === subAccountId);
+    const tokenAccount = subAccountId ? subAccounts?.find(ta => ta.id === subAccountId) : null;
 
     res.asset = {
       type: tokenAccount?.token.tokenType ?? "token",
@@ -155,6 +168,7 @@ export function transactionToIntent(
   } else {
     res.memo = { type: "NO_MEMO" };
   }
+
   return res;
 }
 
@@ -188,9 +202,7 @@ export const buildOptimisticOperation = (
     },
   };
 
-  const tokenAccount = !subAccountId
-    ? null
-    : subAccounts && subAccounts.find(ta => ta.id === subAccountId);
+  const tokenAccount = subAccountId ? subAccounts?.find(ta => ta.id === subAccountId) : null;
   if (tokenAccount && subAccountId) {
     operation.subOperations = [
       {

package/src/bridge/impl.ts

@@ -27,6 +27,7 @@ import { getCryptoAssetsStore, setCryptoAssetsStore } from "./crypto-assets";
 const alpacaized = {
   xrp: true,
   stellar: true,
+  tezos: true,
 };
 
 // let accountBridgeInstance: AccountBridge<any> | null = null;

package/src/e2e/enum/Network.ts

@@ -7,6 +7,7 @@ export enum Network {
   DOGECOIN = "Dogecoin",
   ETHEREUM = "Ethereum",
   ETHEREUM_HOLESKY = "Ethereum Holesky",
+  ETHEREUM_HOODI = "Ethereum Hoodi",
   ETHEREUM_SEPOLIA = "Ethereum Sepolia",
   ETHEREUM_CLASSIC = "Ethereum Classic",
   SOLANA = "Solana",

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

@@ -29,6 +29,7 @@ const createTransaction = (): CantonTransaction => {
     family: "canton",
     amount: new BigNumber(0),
     recipient: "",
+    tokenId: "Amulet",
     fee: null,
   };
 };

package/src/families/canton/config.ts

@@ -13,6 +13,7 @@ export const cantonConfig: Record<string, ConfigInfo> = {
       minReserve: 0,
       useGateway: true,
       networkType: "mainnet",
+      nativeInstrumentId: "Amulet",
     },
   },
   config_currency_canton_network_devnet: {
@@ -42,6 +43,7 @@ export const cantonConfig: Record<string, ConfigInfo> = {
       minReserve: 0,
       useGateway: false,
       networkType: "localnet",
+      nativeInstrumentId: "Amulet",
     },
   },
 };

package/src/families/evm/config.ts

@@ -348,6 +348,22 @@ const evmConfig: CurrencyLiveConfigDefinition = {
       showNfts: false,
     },
   },
+  config_currency_core: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+      node: {
+        type: "external",
+        uri: "https://rpc.ankr.com/core",
+      },
+      explorer: {
+        type: "none",
+      },
+      showNfts: false,
+    },
+  },
   config_currency_fantom: {
     type: "object",
     default: {
@@ -786,6 +802,16 @@ const evmConfig: CurrencyLiveConfigDefinition = {
       showNfts: false,
     },
   },
+  config_currency_ethereum_hoodi: {
+    type: "object",
+    default: {
+      status: { type: "active" },
+      node: { type: "ledger", explorerId: "eth_hoodi" },
+      explorer: { type: "ledger", explorerId: "eth_hoodi" },
+      gasTracker: { type: "ledger", explorerId: "eth_hoodi" },
+      showNfts: false,
+    },
+  },
   config_currency_arbitrum_sepolia: {
     type: "object",
     default: {

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

@@ -0,0 +1,66 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`kaspa currency bridge scanAccounts kaspa seed 1 1`] = `
+[
+  {
+    "balance": "13370000",
+    "currencyId": "kaspa",
+    "derivationMode": "",
+    "freshAddress": "kaspa:qz49rpg0q6ywewxkwl76757ya79v6j556hcmrcy7mk9d36ewgp80cdrwlct2h",
+    "freshAddressPath": "44'/111111'/0'/0/1",
+    "id": "js:2:kaspa:41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a5576:",
+    "index": 0,
+    "operationsCount": 1,
+    "pendingOperations": [],
+    "seedIdentifier": "41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a5576",
+    "spendableBalance": "13370000",
+    "swapHistory": [],
+    "syncHash": undefined,
+    "used": true,
+    "xpub": "41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a5576",
+  },
+  {
+    "balance": "0",
+    "currencyId": "kaspa",
+    "derivationMode": "",
+    "freshAddress": "kaspa:qpncmme6ues25uk9umkqju4rtwtt33ud9lcrp7qn8jwv62m53m26jpjhar48j",
+    "freshAddressPath": "44'/111111'/1'/0/0",
+    "id": "js:2:kaspa:4104751b5ebd4a9d2a0a25d5c37cab4814a95335b8945cfcaa6a4138de418f581bb1d0d02f22081b3cda223a51e18a63ebdffd64803e0988b68a91802738a5a9f901206d4a2b989a82b5fb160f0151ea5d046451a291a0748f3038ecdc63d637cce00b:",
+    "index": 1,
+    "operationsCount": 0,
+    "pendingOperations": [],
+    "seedIdentifier": "41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a5576",
+    "spendableBalance": "0",
+    "swapHistory": [],
+    "syncHash": undefined,
+    "used": false,
+    "xpub": "4104751b5ebd4a9d2a0a25d5c37cab4814a95335b8945cfcaa6a4138de418f581bb1d0d02f22081b3cda223a51e18a63ebdffd64803e0988b68a91802738a5a9f901206d4a2b989a82b5fb160f0151ea5d046451a291a0748f3038ecdc63d637cce00b",
+  },
+]
+`;
+
+exports[`kaspa currency bridge scanAccounts kaspa seed 1 2`] = `
+[
+  [
+    {
+      "accountId": "js:2:kaspa:41049d8002c08041d975ab58491c09cf8ced7b388a114ab2f5df73f2534d4d74d17ab8913b3cb3056bad63141cb63fb92e44401b691dee069dbdb2119861c18cc01b204340fcc305ab72e752cd347f4b6271ffe21da098d4f2a4749826857dda7a5576:",
+      "blockHash": "c11f5877fc777b59a180de2da6bd02046e19219a9bda714c304ada1d3af7144b",
+      "blockHeight": 194187672,
+      "extra": {},
+      "fee": "2069",
+      "hash": "ed6dc5422558c3480e6a7809bf166e6ba1f2931ef39f24fe9b3bcf48253e4752",
+      "id": "ed6dc5422558c3480e6a7809bf166e6ba1f2931ef39f24fe9b3bcf48253e4752",
+      "recipients": [
+        "kaspa:qzavrhr9eg0k7pgr8mysfej34alfy8uj6vc9r84kgqfkqd8rtgxm5t0jvah73",
+        "kaspa:qqt874j85r5ga5av0q6tthj2tu89dfpchjmvjuvx5tyn2vpjjrhk7tcpsx2vu",
+      ],
+      "senders": [
+        "kaspa:qqt874j85r5ga5av0q6tthj2tu89dfpchjmvjuvx5tyn2vpjjrhk7tcpsx2vu",
+      ],
+      "type": "IN",
+      "value": "13370000",
+    },
+  ],
+  [],
+]
+`;

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

@@ -2,7 +2,4 @@ import "../../__tests__/test-helpers/setup";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
 import { dataset } from "@ledgerhq/coin-kaspa/test/index";
 
-// FIXME: Disabled due to live blockchain data changes (blockHash)
-describe.skip("kaspa integration", () => {
-  testBridge(dataset);
-});
+testBridge(dataset);

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/featureFlags/defaultFeatures.ts

@@ -97,6 +97,8 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencyHyperevm: DEFAULT_FEATURE,
   currencyCantonNetwork: DEFAULT_FEATURE,
   currencyKaspa: DEFAULT_FEATURE,
+  currencyEthereumHoodi: DEFAULT_FEATURE,
+  currencyCore: DEFAULT_FEATURE,
 };
 
 /**

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,